{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*************************************************\n",
    "*************************************************\n",
    "<h1 align=center>第四章 辅助商家实现市场价格发现</h1> \n",
    "\n",
    "<a id=\"ref10\"></a>\n",
    "## 目录表\n",
    "\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "<li><a href=\"#ref11\">实验4-1 利用决策树算法构建价格预测模型</a></li>\n",
    "<li><a href=\"#ref12\">实验4-2 基于模型辅助商家实现市场价格发现</a></li>\n",
    "\n",
    "    \n",
    "<br>\n",
    "<p></p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "************************************************************\n",
    "************************************************************\n",
    "<a id=\"ref11\"></a>\n",
    "<h2 align=center>实验4-1 利用决策树算法构建价格预测模型</h2>\n",
    "\n",
    "建议课时：40分钟\n",
    "\n",
    "## 一、实验目的\n",
    "\n",
    "1、sssss\n",
    "\n",
    "2、了解sklearn，xgboost的使用\n",
    "\n",
    "## 二、实验环境\n",
    "\n",
    "Python3开发环境，第三方包有pandas，sklearn，xgboost\n",
    "\n",
    "## 三、实验原理\n",
    "\n",
    "本节将利用决策树算法构建价格预测模型，需要利用的第三方包有sklearn，xgboost。在机器学习中，决策树是一个预测模型，他代表的是对象属性与对象值之间的一种映射关系。Sklearn包含决策树算法的各种常用算法，而xgboost是决策树发展而来的一项集成且高效的算法，在xgboost包中支持一站式调用。\n",
    "\n",
    "## 四、实验步骤讲解\n",
    "本节处理的内容有：\n",
    "模型构建处理流程如下：\n",
    "\n",
    " 1、读取数据\n",
    " \n",
    " 2、平衡数据\n",
    " \n",
    " 3、处理离散型特征\n",
    " \n",
    " 4、划分测试集训练集\n",
    " \n",
    " 5、模型构建\n",
    " \n",
    " 6、模型效果\n",
    " \n",
    "特征选择再转向模型构建，择优保留最佳模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 五、实验步骤\n",
    "\n",
    "### 步骤1:读取“wine_processed.csv”数据\n",
    "\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>price</th>\n",
       "      <th>keyword</th>\n",
       "      <th>产区</th>\n",
       "      <th>葡萄品种</th>\n",
       "      <th>甜度</th>\n",
       "      <th>口感</th>\n",
       "      <th>颜色</th>\n",
       "      <th>原产地</th>\n",
       "      <th>特性</th>\n",
       "      <th>国产/进口</th>\n",
       "      <th>...</th>\n",
       "      <th>品丽珠（Cabernet Franc）</th>\n",
       "      <th>西拉/设拉子（Syrah/Shiraz）</th>\n",
       "      <th>内比奥罗（Nebbiolo）</th>\n",
       "      <th>梅洛（Merlot）</th>\n",
       "      <th>仙粉黛（Zinfandel）</th>\n",
       "      <th>马尔贝克（Malbec）</th>\n",
       "      <th>长相思（Sauvignon Blanc）</th>\n",
       "      <th>佳美（Gamay）</th>\n",
       "      <th>year</th>\n",
       "      <th>alcohol</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0-50</td>\n",
       "      <td>通化/tonghua</td>\n",
       "      <td>其它</td>\n",
       "      <td>赤霞珠（Cabernet Sauvignon）</td>\n",
       "      <td>半干型</td>\n",
       "      <td>饱满</td>\n",
       "      <td>宝石红</td>\n",
       "      <td>法国</td>\n",
       "      <td>普通餐酒</td>\n",
       "      <td>进口</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0-50</td>\n",
       "      <td>长城/greatwall</td>\n",
       "      <td>其它</td>\n",
       "      <td>赤霞珠（Cabernet Sauvignon）</td>\n",
       "      <td>干型</td>\n",
       "      <td>柔和</td>\n",
       "      <td>宝石红</td>\n",
       "      <td>中国</td>\n",
       "      <td>普通餐酒</td>\n",
       "      <td>国产</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 35 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "  price        keyword  产区                     葡萄品种   甜度  口感   颜色 原产地    特性  \\\n",
       "0  0-50     通化/tonghua  其它  赤霞珠（Cabernet Sauvignon）  半干型  饱满  宝石红  法国  普通餐酒   \n",
       "1  0-50  长城/greatwall   其它  赤霞珠（Cabernet Sauvignon）   干型  柔和  宝石红  中国  普通餐酒   \n",
       "\n",
       "  国产/进口  ...  品丽珠（Cabernet Franc）  西拉/设拉子（Syrah/Shiraz）  内比奥罗（Nebbiolo）  \\\n",
       "0    进口  ...                    0                     0               0   \n",
       "1    国产  ...                    0                     0               0   \n",
       "\n",
       "   梅洛（Merlot）  仙粉黛（Zinfandel）  马尔贝克（Malbec）  长相思（Sauvignon Blanc）  佳美（Gamay）  \\\n",
       "0           0               0             0                     0          0   \n",
       "1           0               0             0                     0          0   \n",
       "\n",
       "   year  alcohol  \n",
       "0     2     12.0  \n",
       "1     2     12.0  \n",
       "\n",
       "[2 rows x 35 columns]"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv(\"wine1_processed.csv\")\n",
    "df.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤2:平衡数据\n",
    "观察每个类别的数据，采用欠采样/过采样的方法对数据进行平衡处理\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "price\n",
       "0-50                        1907\n",
       "100-150                     1465\n",
       "1000-2000                    239\n",
       "150-250                     1758\n",
       "2000-9223372036854775807     419\n",
       "250-500                     1664\n",
       "50-100                      3158\n",
       "500-1000                     760\n",
       "dtype: int64"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby(\"price\").size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由此可见，[1000-2000],[2000-MAX],[500-1000]的价格区间需要增长一定的量，通过复制的方式增加该价格区间的数据量；[50-100]的数据量较多，欠采样该价格区间的数据。\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "price\n",
      "0-50                        1907\n",
      "100-150                     1465\n",
      "1000-2000                   1673\n",
      "150-250                     1758\n",
      "2000-9223372036854775807    1676\n",
      "250-500                     1664\n",
      "50-100                      1579\n",
      "500-1000                    1520\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 平衡数据\n",
    "tmp1 = df[df.price=='1000-2000']\n",
    "tmp2 = df[df.price=='2000-9223372036854775807']\n",
    "tmp3 = df[df.price=='500-1000']\n",
    "for i in range(6):\n",
    "    df = df.append(tmp1, ignore_index=True)\n",
    "for j in range(3):\n",
    "    df = df.append(tmp2,ignore_index=True)\n",
    "df = df.append(tmp3,ignore_index=True)\n",
    "\n",
    "## 剔除50-100的一半数据\n",
    "tmp4 = df[df.price=='50-100']\n",
    "df = df[df.price!='50-100']\n",
    "df = df.append(tmp4[::2],ignore_index=True)\n",
    "\n",
    "print(df.groupby(\"price\").size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从结果看，各个价格区间的数据量持平。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤3:处理离散型特征\n",
    "\n",
    "    算法不允许“绿色”这种非数值型特征，需要做转换处理\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(13242, 34)\n",
      "(13242,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "price                      1.000000\n",
       "国产/进口                      0.195261\n",
       "原产地                        0.152645\n",
       "keyword                    0.080821\n",
       "year                       0.061858\n",
       "产区                         0.054137\n",
       "西拉/设拉子（Syrah/Shiraz）       0.053980\n",
       "特性                         0.053849\n",
       "口感                         0.051458\n",
       "其它                         0.036522\n",
       "冰酒/贵腐/甜酒                   0.035893\n",
       "佳美娜（Carmenere）             0.031994\n",
       "蛇龙珠（Cabernet Gernischt）    0.031901\n",
       "长相思（Sauvignon Blanc）       0.030736\n",
       "果味葡萄酒                      0.028160\n",
       "佳美（Gamay）                  0.026670\n",
       "品丽珠（Cabernet Franc）        0.022594\n",
       "红葡萄酒                       0.022299\n",
       "葡萄品种                       0.021176\n",
       "alcohol                    0.020931\n",
       "赤霞珠（Cabernet Sauvignon）    0.019305\n",
       "起泡酒/香槟                     0.018509\n",
       "仙粉黛（Zinfandel）             0.014338\n",
       "梅洛（Merlot）                 0.014051\n",
       "匹诺塔吉（Pinotage）             0.009463\n",
       "黑皮诺（Pinot Noir）            0.009138\n",
       "颜色                         0.007674\n",
       "内比奥罗（Nebbiolo）             0.006996\n",
       "甜度                         0.006611\n",
       "白葡萄酒                       0.006134\n",
       "雷司令（Riesling）              0.005341\n",
       "桃红葡萄酒                      0.004729\n",
       "霞多丽（Chardonnay）            0.001985\n",
       "马尔贝克（Malbec）               0.001143\n",
       "桑娇维塞（Sangiovese）           0.001033\n",
       "Name: price, dtype: float64"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "le1 = LabelEncoder()\n",
    "# 划分X,Y\n",
    "X = df[df.columns.difference(['price'])]      \n",
    "Y = df['price']\n",
    "print(X.shape)\n",
    "print(Y.shape)\n",
    "df1 = df.copy()\n",
    "col = df1.columns\n",
    "for c in col:\n",
    "    df1[c]=le1.fit_transform(df1[c].astype(str))\n",
    "corr_m = df1.corr()\n",
    "corr_m.style.background_gradient(cmap='coolwarm')\n",
    "\n",
    "c= corr_m['price'].abs()\n",
    "c = c.sort_values(ascending=False)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-153-187b296ac4b5>:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  X[f] = cc.transform(X[f])\n"
     ]
    }
   ],
   "source": [
    "# 对非字符型特征进行数值编码\n",
    "# X = pd.get_dummies(X)        #onehot编码\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "le = LabelEncoder()\n",
    "features = [col for col in X.columns.values if X[col].dtype == \"object\"]         #筛选出object类型的特征\n",
    "encoders = dict()\n",
    "for f in features:\n",
    "    cc = le.fit(X[f])\n",
    "    encoders[f] = cc.classes_\n",
    "    X[f] = cc.transform(X[f])\n",
    "#     X[f] = le.fit_transform(X[f])\n",
    "\n",
    "# 保存字符转换的规则\n",
    "import pickle\n",
    "with open(\"encoders.dict\", \"wb\") as f:\n",
    "    pickle.dump(encoders, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "alcohol                    int32\n",
       "keyword                    int32\n",
       "year                       int32\n",
       "产区                         int32\n",
       "仙粉黛（Zinfandel）             int32\n",
       "佳美娜（Carmenere）             int32\n",
       "佳美（Gamay）                  int32\n",
       "其它                         int32\n",
       "内比奥罗（Nebbiolo）             int32\n",
       "冰酒/贵腐/甜酒                   int32\n",
       "匹诺塔吉（Pinotage）             int32\n",
       "原产地                        int32\n",
       "口感                         int32\n",
       "品丽珠（Cabernet Franc）        int32\n",
       "国产/进口                      int32\n",
       "果味葡萄酒                      int32\n",
       "桃红葡萄酒                      int32\n",
       "桑娇维塞（Sangiovese）           int32\n",
       "梅洛（Merlot）                 int32\n",
       "特性                         int32\n",
       "甜度                         int32\n",
       "白葡萄酒                       int32\n",
       "红葡萄酒                       int32\n",
       "葡萄品种                       int32\n",
       "蛇龙珠（Cabernet Gernischt）    int32\n",
       "西拉/设拉子（Syrah/Shiraz）       int32\n",
       "赤霞珠（Cabernet Sauvignon）    int32\n",
       "起泡酒/香槟                     int32\n",
       "长相思（Sauvignon Blanc）       int32\n",
       "雷司令（Riesling）              int32\n",
       "霞多丽（Chardonnay）            int32\n",
       "颜色                         int32\n",
       "马尔贝克（Malbec）               int32\n",
       "黑皮诺（Pinot Noir）            int32\n",
       "dtype: object"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=df1.copy()\n",
    "X = df[df.columns.difference(['price'])]      \n",
    "Y = df['price']\n",
    "X.dtypes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤4：划分测试集训练集\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split  \n",
    "\n",
    "# 划分数据训练集，测试集\n",
    "# 80%训练集，20%的测试集；为了复现实验，设置一个随机数,划分结果是确定的\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2, random_state = 42 )  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤5:模型构建\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 模型相关（载入模型--训练模型--模型预测）\n",
    "from xgboost import XGBClassifier\n",
    "model = XGBClassifier(learning_rate=0.15, n_estimators=320, objective= \"multi:softmax\", num_class=8, max_depth=12, subsample =0.95)\n",
    "model.fit(x_train,y_train)            # 训练模型（训练集）\n",
    "y_pred = model.predict(x_test)        # 模型预测（测试集），y_pred为预测结果\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\98657\\appdata\\local\\programs\\python\\python38\\lib\\site-packages\\sklearn\\model_selection\\_split.py:293: FutureWarning: Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuarcy: 77.01%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from mlxtend.regressor import StackingCVRegressor\n",
    "from lightgbm import LGBMRegressor\n",
    "from sklearn.model_selection import cross_val_score,KFold\n",
    "from sklearn.linear_model import LinearRegression, Lasso, Ridge\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X = df[df.columns.difference(['price'])]      \n",
    "Y = df['price']\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2, random_state = 101 ) \n",
    "\n",
    "\n",
    "\n",
    "rf_params = {\"max_depth\": 20, \"max_features\": 30, \"n_estimators\": 152}\n",
    "svr_params = {\n",
    "    \"kernel\": \"poly\",\n",
    "    \"C\": 0.053677105521141605,\n",
    "    \"epsilon\": 0.03925943476562099,\n",
    "    \"coef0\": 0.9486751042886584,\n",
    "}\n",
    "ridge_params = {\n",
    "    \"alpha\": 0.9999189637151178,\n",
    "    \"tol\": 0.8668539399622242,\n",
    "    \"solver\": \"cholesky\",\n",
    "}\n",
    "lasso_params = {\"alpha\": 0.0004342843645993161, \"selection\": \"random\"}\n",
    "lgbm_params = {\n",
    "    \"num_leaves\": 16,\n",
    "    \"max_depth\": 6,\n",
    "    \"learning_rate\": 0.16060612646519587,\n",
    "    \"n_estimators\": 64,\n",
    "    \"min_child_weight\": 0.4453842422224686,\n",
    "}\n",
    "random_state =101\n",
    "cv = KFold(n_splits=12, random_state=random_state)\n",
    "\n",
    "svr = SVR(**svr_params)\n",
    "ridge = Ridge(**ridge_params, random_state=random_state)\n",
    "lasso = Lasso(**lasso_params, random_state=random_state)\n",
    "lgbm = LGBMRegressor(**lgbm_params, random_state=random_state)\n",
    "rf = RandomForestClassifier(**rf_params, random_state=random_state)\n",
    "rfr = RandomForestRegressor(**rf_params, random_state=random_state)\n",
    "stack = StackingCVRegressor(\n",
    "    regressors=[svr, ridge, lasso, lgbm, rf],\n",
    "    meta_regressor=LinearRegression(n_jobs=-1),\n",
    "    random_state=random_state,\n",
    "    cv=cv,\n",
    "    n_jobs=-1,\n",
    ")\n",
    "\n",
    "rf.fit(x_train,y_train)            # 训练模型（训练集）\n",
    "y_pred = rf.predict(x_test)\n",
    "from sklearn.metrics import accuracy_score   # 准确率\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"accuarcy: %.2f%%\" % (accuracy*100.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤6：模型效果评估\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuarcy: 77.50%\n",
      "                  precision    recall  f1-score   support\n",
      "\n",
      "            0-50       0.72      0.72      0.72       401\n",
      "          50-100       0.77      0.77      0.77       290\n",
      "         100-150       1.00      0.92      0.96       374\n",
      "         150-250       0.62      0.68      0.65       332\n",
      "         250-500       0.99      0.95      0.97       344\n",
      "        500-1000       0.79      0.82      0.80       300\n",
      "       1000-2000       0.50      0.49      0.49       292\n",
      "2000-sys.maxsize       0.78      0.81      0.79       316\n",
      "\n",
      "        accuracy                           0.78      2649\n",
      "       macro avg       0.77      0.77      0.77      2649\n",
      "    weighted avg       0.78      0.78      0.78      2649\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 性能评估\n",
    "from sklearn.metrics import accuracy_score   # 准确率\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"accuarcy: %.2f%%\" % (accuracy*100.0))\n",
    "import sys\n",
    "from sklearn.metrics import  classification_report\n",
    "#输出详细的分类性能\n",
    "scope = [[0,50],[50,75],[75,100],[100,150],[150,200],[200,250],[250,300],[300,400],[400,500],[500,1000],[1000,2000],[2000,sys.maxsize]]\n",
    "print(classification_report(y_pred,y_test,target_names=['0-50','50-100','100-150','150-250','250-500','500-1000','1000-2000','2000-sys.maxsize']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤7：特征选择与再训练\n",
    "首先查看模型各个维度的重要性：\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "price\n",
       "0    385\n",
       "1    287\n",
       "2    397\n",
       "3    326\n",
       "4    329\n",
       "5    335\n",
       "6    314\n",
       "7    276\n",
       "dtype: int64"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label = pd.DataFrame(y_test,columns=[\"price\"])\n",
    "label.groupby(\"price\").size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "prediction\n",
       "0    404\n",
       "1    268\n",
       "2    426\n",
       "3    328\n",
       "4    326\n",
       "5    317\n",
       "6    282\n",
       "7    298\n",
       "dtype: int64"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction = pd.DataFrame(y_pred,columns=[\"prediction\"])\n",
    "prediction.groupby(\"prediction\").size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRsAAAacCAYAAACc5klNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9ebyeVX0v/H8yb0j2zrDZDElAwGExiAzizCQgKKLR1lpty5GK1VPrqec8fY49bX0e2yN67HnKz1N6qsdzilWrONURBBoBQwCJKENkkFWGQEbMQEh2JNlk+v1x30k3ISQBL/a9d/J+v1557fta97qu67s2S5APa13XqK1btwYAAAAA4Nc1utMFAAAAAAB7B2EjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0IixnS4AAACerVLKa5J8KckHk4xL8vtJvlVr/VpHC3uWSinzkvynWustna4FAKAJVjYCADDitMO5JbXWH9Zar0ry20mmPNfrlVJKU7U9S7+d5KdDfdMOjhcA2MsJGwEAGPFqrVuS/O/ncm4p5aAkH262oj2675gkfbXWTUN4z1GllPOTvHqo7gkA7FtsowYAYMQrpby91vqd9ufzkvQl2ZpkdK31C6WUriT/KcltSfZPMq3W+vlSyrQkRyc5spRyRpJHa633lVJ+O8nRtda/LKUcleS/1VrfXko5N61g8m+SHJjkgiQfqLUuLqX8YZLlSQ5Ncmut9ce7qHd0klOTfLz9M6WUyUmuTvI/k7wpybVJTk/y/iSfSLJfWqsge5KsqLV+oz2uP0pyV5IXJLmt1np7KeU3kvxZkvclKWltNz83yQuTvCjJwe3x3llrfbyU8ookJyV5IMmrkny51rqwlPK5JI8muTvJCUm+Vmu9q5Syf5IPJbkjycuT/KDdPibJf0zyUPu+36m11j36iwgA7BWsbAQAYKSaUko5o5Ty7iQvTZJSypQkv1Fr/WKt9UtJTiul9KUV1N2W5IdJbk9ydpLUWh+rtc5JK2ScU2u9r33tn2y7SbttTfvzvyS5NcmR7edDvqsdNJ6dZGut9VtJ/jbJn+6q8FrrlvZ9HxzUtibJg7XWy5NsTvJPSRYmmZFWCPmvtdZ/qrX+fZIL28Hef04yp9Y6u9b6f5J8tH2tbye5J62Vk99I8tZa60Ct9d4kdya5rz3ex9u3n5jkO0l+nGRpkjPa7bekFUh+M61nZJ7fbv8vSX5Ua/1h+3fa127//ST3tIPfS5P81a5+DwDA3sfKRgAARqrH24FdSikva7e9OElXe9Ve0lqRNymtAO2VaT3X8Z4kv+7W5WuTpNba3z4+McnWQff9+XO87uZtH2qtW9qPVhzVblo3qN+aJL1prUL8/wa1P1lKOaDWurJ9jW11rt3NfdckuSitQHZDkq5B361u/xxIMqH9+eVJPtm+9m2D+p6YZMOg38Ndu7kvALCXsbIRAIARr9a6Ldx7KMmm9qq9OUm+nmRRkvcmubfW+o1a6z1JtpRSxg26xKYkKaUcWUoZlVbgNq7dNj6trcu78osk/YPu+w/NjOwpxgz6PDXJirRWaR45qH3ctqBxFwa2XauU8sJ2218n+eta6+y0tk1nh9/Pju5L8pJtB4PC3l+ktcV72+/hy7upBQDYy1jZCADAiFNKOSWt5w6+sNY6eCvyqlLKVaWU/5BkZZL1tdbvllJuTvL7pZQtaf0H97FpPcPwyvapvyil/HFa26kfSvJoKWVaKeU/pbWyb3Mp5bAkM5Mck+TsUsqN255HWGu9spTyp6WU96W1AnFhkkd2Uf/oJGcmOaKU8pa0QsN1SV5USjkiyeHtN0aXtEK9J5OcWkp5LK3nLl5Sa91aSvnrJH9QSpmR5JC0QsOUUgZfe36tdeGg289P8p7272LbysPZ7ev8MslBSY5q13RSWluk5yQ5Ocmx7ec1fjLJR0opJ6UV1G4Le/93kj8vpRySVmD7i139HgCAvc+orVu3droGAABgF9rbkg+vtX6hw6UAAOySbdQAADD8vSbJa0opEztdCADArljZCAAAAAA0wspGAAAAAKARwkYAAAAAoBHeRs3ebkKSVyRZlmRzh2sBAAAA2BuMSXJIkp8mGRj8hbCRvd0rktzY6SIAAAAA9kKnJrlpcIOwkb3dsiRZvfpX2bLFy5AYvnp7J2XVqnWdLgN2yTxlJDBPGSnMVUYC85SRwDztjNGjR2Xq1IlJO3cZTNjI3m5zkmzZslXYyLBnjjISmKeMBOYpI4W5ykhgnjISmKcd9bRH1nlBDAAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANCIUVu3bu10DfB8OjzJgk4XAQAAADw3GwY2pX/t+p1+19fXnRUr+oe4IkaPHpXe3klJckSShwd/N7YTBcFQu+ji2Vm+eud/YwIAAACGrysumRVx4shhGzUAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANCIsZ0uAAAAAAB2ZdmypfnUpy7OlCmTkyR/+Id/nOuv/2GOOeYlWbVqbc4665yn9fnIR/4imzdvyZVXfjczZhyaTZs25qyzzkmSXHbZ59Ld3ZPJkyfn3HPP69i49kbCRnarlDI2yfm11u8Og1pGJZlea13S6VoAAACAofPe974/xx9/QpLky1/+Qs4++9wcd9xL8jd/8z/S39//tD6D+x188CH54hcvS39/f5YuXZIJEybkne98dz71qY/nzDPfkHHjxnVgRHsn26jZE8cneVuni2h7bZJPdLoIAAAAoHOWLVua3t4DkiTTpvXm3nvv3uN+8+bdnOOOOyFJMmPGobn33nuGpOZ9hbCR3aq13tbpGraptd7c6RoAAACAoffTn87L17725Xzuc3+fmTMPy/3312zdujX33HNX1q5d87Q+SXbab+XKlZk6dUqSpKenJ6tWrezUkPZKtlHzrJRS/jHJN5L8JMl7kixI8uJa6/9XSjkiybeTvDnJEUnem+Qvk3wtyX9IckmSC5N8JMkfJ/ntJGuS9CRZ3L7mbyV5Z5LPJjkxyZpa62dKKRcmGZfkiSEYJgAAADCMvPjFh+U97/ndTJ8+PZdeemne9Kazc8MNN2TlyqV54QsPz4wZBz6tz8DAmrzvfe/J5Zdf/pR+998/LlOnTkxfX3cmTZqQyZP3S19fd6eHuNcQNrLHSim/keTvaq23l1L+e5K/qbUuL6X8x1LKybXWn5VSvpakK8n4JH9Va11USvlJkvlJNibZkuQfkhyZ5Iha6yfa1/7HJDfVWr9SSnl/kruT/EuSrlJKX5JX1Fr/qN33DUM7cgAAAKCTli1bnSRZsaI/EydOyZIlKzNr1m+nr687f/VXn0hPT9/T+jzwwKIce+zkzJr120mSz3zm0vT09GXixMlZsGBJurv7snTp8vT1zciKFf0dG9tINHr0qPT2Ttr5d0NcCyPXS5O8Lskx7eMXJTmmlHJGktVJRrXbv5bW8x2n11oXttvuSfKOJA+0rzE/yQnt4202JDmg/XlBrXVxrXVrrXV9WsHkw42PCAAAABgRrr76isyff3uSZOXKFRk1Kpk378dJkieeeCIzZx76tD7Tp0/PkiWLn9bvVa96be6+++dJksWLF+WYY17agRHtvYSN7Klf1Fr/JMn5pZQpSRYmubvWOifJP6cdHNZaH0lySFqrGLeZm1YA+f0kJ9datyS5K8lhg/qMT/JMD0lYmOTAJCmlTGtmOAAAAMBIcfbZ5+axxx7LnDnXZdq0aTnggL7MnfujfOlLX8p5552/0z5Tp07LuHHjMnfuj/LNb35te7+jjjo6AwMD+cY3Ls+JJ748Y8fa+NukUVu3bu10DQxzpZTjk/xdkrckeVNaweH/ndYzGR9MK7T+SjtETCnlPyS5ttb6i0HX+H+T/G2S99ZaP91u+520ntm4f5KlSW5LclqSv0ry/yS5oda6cdA11yZ5LMn7klxYa129B+UfnmTBRRfPzvLV65/7LwEAAADoiCsumfWM25z7+rptge6AQduoj8gOu1GFjTSulPJbtdZvdrqOtsMjbAQAAIARS9g4/OwqbLROlMaUUiYm+WqS/9npWgAAAAAYesJGGlNr/VWSt3a6DgAAAAA6wwtiAAAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGeEEM+4TLPnpOp0sAAAAAnoMNA5s6XQLPgrCRfcKqVeuyZcvWTpcBz6ivrzsrVvR3ugzYJfOUkcA8ZaQwVxkJzFPgubCNGgAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABoxNhOFwBDobd3UqdLgN3q6+vudAmwW+YpI4F5yq5sGNiU/rXrO10GAOy1hI3sEy66eHaWr/Z/KgEA9nVXXDIr/Z0uAgD2YrZRAwAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRjb6QIAAACG0tq1a3PDDddn3Lhx2bJlS0477fX54Q+vSW/vAXn88dV561vfniS57LLPpbu7J5MnT865556XzZs35+qrr0x3d08WLHgwF174vqxbt26n5wLAvsrKRp6zUsoppZTn9P+mSik9pZRznmX/jz2XewEAwGDz59+eSZMm5Y1vfHPuuOO2XHPNlXnDG96Y0047Iz09PXnooQdS632ZMGFC3vnOd+eOO27Lxo0bc+ut89Ld3Z3TT399urq68tBDD+z0XADYlwkbeU5KKSXJaUkmP8dL/EGS6Xt4r3FJXpnkNc/xXgAAsN2pp56RM844K0kyduy47L//xMybd3OSZM2aNZk4cVLmzbs5xx13QpJkxoxDc++99+Sggw7KmDFjtl9n/PgJOz0XAPZlwkaek1prTfLjX+MStz2Le22stV6b5NFf434AALDd+vVP5NOf/u8544wzc+655+W662bnk5/8q4wbNy4HHXRwVq5cmalTpyRJenp6smrVyhx55ItyyimnJ0mWLl2SGTNm7vRcANiXeWYju1VKOTLJm5PcleTMJH9Ta137DH0/lOS+JK9I8uVa66JSyuuSHJ7ksSQH1Fr/qd391aWU0Ulel+S/1lof2UVfAABoRF9fd5LufPKTH8/HP/7xHHTQ1Jx//nnp6urKl7/85bz73e/IfvuNy9SpE9PX151JkyZk8uT92uclV111VT74wQ/kwAN78q//+q9PO3f8+PHPog4Y3sxTRgLzdHgRNrInJia5Mq2Vha9LckKSuTt2KqWcm2RdrfXaUsr6JFNLKYuT/EGt9cJ2nz8vpbykfco9tdbPl1IWJjml/fNpfWut//r8Dg8AgH3Jgw8uyZgxozNx4qQcfPCh+Yu/+Gi++MWvZezYsVmwYFGuuuraTJw4OQsWLEl3d1+WLl2evr4ZWbGiP/fee3e6unrS1TUlK1b05xvf+HYuuugDTzn3da87dbc19PV1Z8WK/iEYLTx35ikjgXnaGaNHj0pv784fHWIbNXvil0kuSHJ6kg155nlzfJJfJEmt9eZa68+THJBk/aA+D7b7Jcm2vxtsSjJuN30BAKAR11zzg9xyS+s5i489tipvetP527/r6zswEyZMyKte9drcfffPkySLFy/KMce8NOvXr8/ixYtz3HHHZ2BgQ+bPvzOTJk162rkAsC8TNrIn/nOSr9Rar0myKsmoUsqYnfR7IMmLth2UUk5KsjKtIHGbw5P8/Bnu82z6AgDAc3L22efk8cdX5/rrr013d0/e8pa35ZprrszcuXPyy18+mpe//BU56qijMzAwkG984/KceOLLM3bs2PzgB9/L3Lk/ysc+9mf50Ifen56enpx//qynnQsA+7JRW7du7XQNDHOllDcleXmSu5MclWRaku8mOSPJIUm+UGu9rf38xf+a5KG0ViveWGtdUEo5rd2vP0l3rfXrpZT/mOTwWut/bH8+stb6x8/QtyvJKe1r/2WSn9ZaV+9h+YcnWXDRxbOzfPX63fUFAGAvd8Uls4bFdjvb/hgJzFNGAvO0MwZtoz4iycODvxM2src7PMJGAADahI2w58xTRgLztDN2FTbaRg0AAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRibKcLgKFw2UfP6XQJAAAMAxsGNnW6BADYqwkb2SesWrUuW7Zs7XQZ8Iz6+rqzYkV/p8uAXTJPGQnMUwCAzrKNGgAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABoxNhOFwBDobd3UqdLgN3q6+vudAmwW+bp82/DwKb0r13f6TIAAOA5ETayT7jo4tlZvtq/uAEw/F1xyaz0d7oIAAB4jmyjBgAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGjG20wUAAPBvNm/enCuv/F66u3uyYMGDOffc8/KpT12cKVMmJ0k+8pG/SFfXfrn66iu397nwwvflgQfuzyc+8bEcdtgL0t+/LrNmvT2nn35mrr32XzJq1Kjceecd+ZM/+dMOjw4AgL2dsBEAYBi56aab0t3dndNPf32WLVuS9eufyHvf+/4cf/wJ2/vccsvNT+nz0EMPZO3aNfnsZz+frq6uzJ59TU455fQsX/7LrFu3Lm9722/mySefzNatWzNq1KjODQ4AgL2ebdQAAMPIIYcckjFjxmw/Hj9+wtP6HHTQQU/rc9JJJ6erqytPPvlktmzZnDFjxmTu3B+llKOSJG960/mCRgAAnndWNgIADCMveclLMnXqIUmSpUuXZPTo0fnpT+flF7+4O2vWrMkHPvBHOfLIF+XII1+0vc+MGTO3n3/99T/MK17xqiTJsmXLsnHjpsyff0ceffTRfPjDfyJwBADgeSVsZEiUUl6W5PNJzk7y5iTHJvnHJG9MsixJb631c6WUI9vf35XkzCR/k6Qnye+2f/68fY3/VWu9bajHAQBDoa+vO1dddVU++MEP5IADDkhf3+9m+vTpufTSSzMwsCYzZ7bCxW19DjywZ/u5Cxc+mAsueFeSZOvWjXnZy47OGWeckW9+85tZuPBfc/LJJ3dkTEOpr6+70yXAHjFXGQnMU0YC83R4ETYyJGqtPy+lzE2ysf3nvya5NMmHaq1PllIuKaUclGRikiuTPJrkdUlOqLXOLaV8PcnnknwsyXfb1wCAvdINN9ySrq6edHVNybJlq5MkK1b0Z+LEKXnggUWZMGFy7r337u19VqzoT5IMDAxkyZJHtx9PmDAxEyb0DDr3kbzgBaVj4xoKfX3d28cPw5m5ykhgnjISmKedMXr0qPT2Ttr5d0NcC/u276a1knFcrXVDkplJXltKOSPJQ0n2T/LLJBckOT3Jhjx1jt5Sa91Uax2otW4ZysIBYKg88cQTWbx4cY477vgMDGzIt7719cyff3uSZOXKFZk+fXrWr1//lD7z59+ZJFm48JGMHz9++7WOP/7E3HffvUmSVatW5bDDXjDk4wEAYN8ibGQo3ZjktCTb/pPDL5PcXGudk+SfkyxO8p+TfKXWek2SVUlGlVLG7ORaALBX+ta3vpW5c3+Uj33sz/KhD70/xx9/Yh577LHMmXNdpk2blqlTp+UHP/jeU/r09LS2UY8ZM3r75yR55StfneXLf5k5c67Lpk2b8uIX792rGgEA6LxRW7du7XQN7ENKKf8tyadqrWtK6/WYv5HkkSQDtdZ/LqW8KcnLk9yd5Kgk05J8Osl5Sc5N8v+rtc57Frc8PMmCiy6eneWr1zc4EgB4flxxySxbgX4NtlIxUpirjATmKSOBedoZg7ZRH5Hk4cHfeWYjQ+32WuuaJKm13pfkk4O/rLVeneTqnZx3WfsPAAAAAMOUbdQMiVLKEaWUb2WHtBsAAACAvYeVjQyJWuuCJL/Z6ToAAAAAeP5Y2QgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANMILYtgnXPbRczpdAgDskQ0DmzpdAgAAPGfCRvYJq1aty5YtWztdBjyjvr7urFjR3+kyYJfMUwAAYHdsowYAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGjG20wXAUOjtndTpEmC3+vq6O10C7JZ52rJhYFP6167vdBkAADDsCBvZJ1x08ewsX+1fCgFoxhWXzEp/p4sAAIBhyDZqAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEWM7XQAjQyllcpKBWuuG3fQbVWvdOkRlAUBHbN68OVde+b10d/dkwYIH8xu/8c7ccMP1GTduXLZs2ZLzzntL1q5dmyuv/G5mzDg0mzZtzFlnnZPNmzfn6quv3H7ehRe+L0ly7bX/klGjRuXOO+/In/zJn3Z4dAAA8NxZ2cgulVI+0f54eJK3l1ImlVIO3km/D7U/vrGU8rJdXO9F7Z9jSykzSinn7KLvftuuW0rpLqX8u+c6DgBo0k033ZTu7u6cfvrr09XVlWuu+UEmTZqUN77xzbnjjtuSJN///rdz5plvyOmnvz6LFy9Kf39/br113lPOe+ihB7J8+S+zbt26nHXWOTnmmGOzdav/ZgcAwMhlZSNPU0p5Y5ID2oeHl1J+J8nxSe5Nck6SR9t/UkoZlWRKkt5SymlJ3pLktlLKa5OsqrV+c4fLn1hKeWuS/iSrkrw0yewd7j82yflJTktycZLUWvtLKfs3PFQAeE4OOeSQPPZY//bj1772lMyYMTNJMnbsuCTJsmVL09vb+sfptGm9uffeu3PQQQdl6dIl288bP35C5s79UY499rgkyZvedP5QDQEAAJ4XwkaeptZ6TZKUUj6Z5KtJ7kmyNcmTSY5O8rP29ycmeW2ScUlmJFmU5Me11i+XUvarta7fyeVXJflZrXVB+xqH7qTPC5L8S5KptdbHSikzaq1Lkmxp939JrfW65kYMAM/OS17ykkydekiSZOnSJZkxY2bWr38in/vc3+eMM85MksyceVjuv7/m6KOPzT333JWurq686lWvyZFHvugp5y1btiwbN27K/Pl35NFHH82HP/wnGTVqVMfGBgAAvw5hIztVSjk2yYK0VjQenOTB9s8l7T+ptd5RSvl5ku8kuTLJG5NMbG99PquUcmGtdc0Olx6X5L2llEeTbE6ybie3PyDJyUleX0pZkeS0Uso9SV6dZEWSQ5IIGwHoqL6+7lx11VX54Ac/kAMP7EnSk09+8uP5+Mc/nte85uV53/vek8svvzwrVy7NC194eGbMODB9fd1J8pTztm7dmJe97OicccYZ+eY3v5mFC/81J598cmcHN8Jt+z3DcGeuMhKYp4wE5unwImzkaUop+yU5PcnaJOuTvDDJ1CR3Jzm41rp5UPd/l+TzaW2lviWtFY4/SrJlx6CxlDI6yY/b/fqTjK21biyljK21bhrU9dEkPUmmJbm1fc8vllLGJbmrXRMAdNQNN9ySrq6edHVNyYMPLsmYMaMzceKkHHzwobn22rk588yzM2vWbydJPvOZS9PT05cVK/pz7713bz9vxYr+TJgwMRMm9GTFiv5MnDglDzzwSF7wgtLh0Y1cfX3dWbGif/cdocPMVUYC85SRwDztjNGjR6W3d9LOvxviWhjm2s9gfGOSb6W1kjBJnkiyIcnCHfqenuSmJDPTCgfPTbK6fbx1h76jknwqyTuTfCLJ+CR/XUr5wyRfLaVM3da31vpIkpOSfD/J2UmOKqVcmOTUJO9OK6gEgI554oknsnjx4hx33PEZGNiQf/7nr+WWW25Okjz22KpMnz4jS5Yszrx5P97ef+bMQ7N+/fqnnDd//p05/vgTc9999yZJVq1alcMOe0HHxgUAAL8uKxt5ilrr1rS2RaeUkiST09q2vO2ZjYPnzF1JfjetlYZTkvSltSLyhuwQNtZat5ZSFtVaLyulfKDWOlBKub39fMfRtdbV2/qWUl6X5Ookr6y1Xl5KeSDJbWmthPyH52PcAPBsfOtb38pNN92Sm2++IUuXLskHP/jhPPjg/bn++mvT3d2To446OsuX/zJz5/4oixYtzHnntV788oMffC933nnH9vP+/M//Mscd97J84Qv/kDlzrsumTZvy4hdb1QgAwMglbGRXlrX/3JbWXNmUZPsT62utjyX5u1LK/53kn5O8KMlr0npr9ct3cr1tAeS49s/RpZSJSSZs61BK6UrSXWu9uZTyqvZ9bm1/95QAEwA65YILLsgb3/i2p7SdeOJT/9F34IEH5SMf+YuntL3jHe/KO97xrqdd773vfX/jNQIAQCcIG9mpUkp3Ws9OnJNkvyQXpLXtfmdb70cnOaX9c13788930u/VpZQxSda3t1Wfnlbw+IvBz23c9jbsDJqfpZSx2WG1JAAAAADDi7CRnaq19pdSvjjoxS3/pf2G6gk76fvft31uvwTmk0n+fCeX/cNaa/+gvn9Sa318h2ttaH83Kk99EcxB8WIYAAAAgGFN2Mgz2uEN0am13rMH52xJ8l+e4bv+HY4f38V1tib5wqDjJaWUr+/u/gAAAAB0jrdRM2K0g0wAAAAAhilhIwAAAADQCGEjAAAAANAIYSMAAAAA0AgviGGfcNlHz+l0CQDsRTYMbNp9JwAA2AcJG9knrFq1Llu2bO10GfCM+vq6s2JF/+47QgeZpwAAwO7YRg0AAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANGJspwuAodDbO6nTJcBu9fV1d7oE2K2RPE83DGxK/9r1nS4DAAD2asJG9gkXXTw7y1f7F0yAfdkVl8xKf6eLAACAvZxt1AAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCPGdroA9i2llLFJRtdan2wfz6y1Lu5wWQDsAzZv3pwrr/xeurt7smDBg7nggt/P1Vdfuf34wgvflwceuD+f+MTHcthhL0h//7rMmvX2nHjiybnyyu9mxoxDs2nTxpx11jlZtmxpPvWpizNlyuQkyUc+8heZOHFSh0cIAACdJ2xkqG1N8sEk/6N9fF4p5Tu11hWDO5VS3pLkp7XWR9vH5ye5u9b68BDWCsBe5Kabbkp3d3dOP/31WbZsSb7znW+mr+/A7ccPPfRA1q5dk89+9vPp6urK7NnX5JRTTs9Xv/pPOfvsc3PwwYfki1+8LP39/UmS9773/Tn++BM6OygAABhmbKNmyJRSpiZ5XZJ17eOeJD1J3lZK+e0duncl2dLuN6n9eePQVQvA3uaQQw7JmDFjth+fdNLJTzkeP35CTjrp5HR1deXJJ5/Mli2bM2bMmCxbtjS9vQckSaZN682999495LUDAMBIYWUjQ2l6kklJppRSjk7ywiQTkvxzrXV1KWV0rXVLu++Y/FsY/sdJ7koyMNQFA7D3eMlLXpKpUw9JkixduiRHHPHCHHnki7Yfz5gxc3vf66//YV7xilclSWbOPCz3319z9NHH5p577kpXV1eS5Kc/nZdf/OLurFmzJh/4wB8N8WgAAGB4EjYylE5IclBaIeNJaQWPY5N8sJSyNMmCJHNKKa9OK2x8eynl5iQPp7XS8SWllFOT3FBrfWzoywdgpOvr685VV12VD37wAznwwJ4kedpxkixc+GAuuOBdSZL3ve89ufzyy7Ny5dK88IWHZ8aMA/PiFx+W97zndzN9+vRceumlGRhYk5kzZ+70ngy9vr7uTpcAe8RcZSQwTxkJzNPhRdjIUFpXa/1KKeXjSX5Wa62llK4kf5ZW0Njb7lfSerbjPyQ5L60Vjqcl+X6SW5OsGfLKAdgr3HDDLenq6klX15SsWNGfe++9+ynHSTIwMJAlSx7dfpwks2a1nvbxmc9cmp6evixbtjpJsmJFfyZOnJIHHliUCRMmD/2AeJq+vu6n/LWD4cpcZSQwTxkJzNPOGD16VHp7d/6CRM9sZCjdUkr5gyRPpvVimL9O8o4kE5MsS2tV45i0gsZtQfjKWuuXk9yQ5KdJltZaNw996QCMdE888UQWL16c4447PgMDG3LHHbc95Xj+/DuTJAsXPpLx48dvP2/JksWZN+/H268xc+ahufrqKzJ//u1JkpUrV2T69OlDPh4AABiOrGxkSJRSJie5MMnfJfndWus/lFL+PMlXknTVWuug7l9qh5JbktxVSnl/khOTHJJkfSnlHwWOADxb3/rWt3LTTbfk5ptvyNKlS/KGN7wpP//5nduP//zP/zJJMmbM6PT0/NuW6nHjxmXu3B9l0aKFOe+885MkZ599bm66aW7mzLku06ZNy9Sp0zoxJAAAGHZGbd26tdM1sI8ppby/1vq/22+ZHkjynlrrP+zQ59/XWv/XoON3J/lerfWJZ3m7w5MsuOji2Vm+ev2vWzoAI9gVl8yyxWYfYCsVI4W5ykhgnjISmKedMWgb9RFpvWtjOysbGVKllGlpbZNOrXVdKeV3k7xoJ11Hl1LGpfW26olJDk3y2lJKd/vc7wxRyQAAAADsIc9sZKitTvLjbQe11q8k+Zed9JuW1turH0xyXZK3JPmPaT3j8Q3tF8sAAAAAMIxY2ciQqrVuTXLPDm0/2knXObXWnyY5aEgKAwAAAODXZmUjw1Kt9aZO1wAAAADAsyNsBAAAAAAaIWwEAAAAABohbAQAAAAAGuEFMewTLvvoOZ0uAYAO2zCwqdMlAADAXk/YyD5h1ap12bJla6fLgGfU19edFSv6O10G7JJ5CgAA7I5t1AAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI8Z2ugAYCr29kzpdAuxWX193p0uA3Xq+5umGgU3pX7v+ebk2AAAwdISN7BMuunh2lq/2L7EAw9UVl8xKf6eLAAAAfm22UQMAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0Y2+kCYHdKKccnOSTJ1CRfr7Vu6XBJADRs8+bNufLK76W7uycLFjyYCy98X5Lkuutm56yzzkmSrF27NjfccH3GjRuXLVu25Lzz3rLTtgceuD+f+MTHcthhL0h//7rMmvX2nH76mZ0cHgAA7DOsbGRIlVIOeIb2rh2OTy6lHFhKeWmSA5O8NckbknyklDL1+a8UgKF00003pbu7O6ef/vp0dXXloYceyE03zc1VV125vc/8+bdn0qRJeeMb35w77rjtGdvWrl2Tz3728/mrv/pveeMb35xTTjm9I2MCAIB9kZWNDLWjSiknJFmfZHxagfehSR5I8g+D+h2f5AVJliZZlOShWuvflFJeVmtdPbQlA/B8O+SQQ/LYY/3bj8ePn5BTTjktN9xw/fa2U089I1u3bk2SjB077hnbTjrp5CTJk08+mS1bNmfMmDFDMgYAAEDYyNBbnKQvyfe2bYcupZyTZOEO/SYmWZbkiLRCxzWllLOTTEvy86ErF4Ch8JKXvCRTpx6SJFm6dElmzJi5037r1z+Rz33u73PGGWfusi1Jrr/+h3nFK171/BUNAAA8jbCRobYpyRM7PHfx0CQ379BvbLt9bVqrHL+c5M9qrb9XSjmk1rpsSKoFYMj09XXnqquuygc/+IEceGBPkqSra1z6+roH9erOJz/58Xz84x/Pa17z8vT29j5DW7Jw4YO54IJ3Df1A6LinzhkYvsxVRgLzlJHAPB1ehI0Mtc1JdtzPNqnW+qttB6WU/ZKsSjIlre3WK5OcmOTbpZTz2+d/b0iqBWDI3HDDLenq6klX15SsWNHaUr1hw8btn9euXZsxY0Zn4sRJOfjgQ3PttXNz8smvfFrbmWeenYGBgSxZ8uj2c9l39PV1++vOiGCuMhKYp4wE5mlnjB49Kr29k3b+3RDXAtvDxlLK+PYLY3acnWcn+VqSq5JckdbzGr+cZH6SJ5O8bOjKBWAoPPHEE1m8eHGOO+74DAxsyPz5dz6tzzXX/CC33NJaCP/YY6syffqMnbYlycKFj2T8+PFDVj8AANAibGSoTU7y6VLKz5L8KK3t0S8tpfQM6jMvyWvSChb3TzKjlDIxyX5JXp/kr4e2ZACeb9/61rcyd+6P8rGP/Vk+9KH3p6enJzfeOCe33/6z3HrrvCTJ2Wefk8cfX53rr7823d09Oeqoo3faliRjxoxOT0/PM98QAAB4Xoza9gZHGAqllAOTHFtr/dEu+hyS5F211k+XUn4jyfW11sdLKeclWZDkvlrrnk7cw5MsuOji2Vm+ev2vWz4Az5MrLpll+wuNsJWKkcJcZSQwTxkJzNPOGLSN+ogkDw/+zjMbGVK11uVJlu+m26+SfK79+btJ/l0pZVpaL4r58LMIGgEAAAAYQsJGhp1a69pBn7ck+ULnqgEAAABgT3lmIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIb6Nmn3DZR8/pdAkA7MKGgU2dLgEAAGiAsJF9wqpV67Jly9ZOlwHPqK+vOytW9He6DNgl8xQAANgd26gBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEaM7XQBMBR6eyd1ugTYrb6+7k6XwBDYMLAp/WvXd7oMAACA54WwkX3CRRfPzvLV/uUe6LwrLpmV/k4XAQAA8DyxjRoAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLCREaGU0t3pGgAAAADYtbGdLoCRr5TysiT3pTWfpieZkeSwJAcnubfW+oMd+k9J8vpa63d2cc1Tkqyutd7TbvqtUsoPa62LnochAAy5666bnbPOOicPPHB/PvGJj+Www16Q/v51mTXr7TnllNNz9dVXpru7JwsWPJgLL3zf9vMWLHgoN9xwfS688H1Zu3Ztbrjh+owbNy5btmzJeee9pYMjAgAAEDbSjK4k/0+Su5OsTXJMkv9da+3fWeda6+OllCdLKYemFUwekeRbtdYnB3VbnWRyKWW/JFuSrGtfG2DEu+mmubnqqitz1lnnZO3aNfnsZz+frq6uzJ59TU455fTceuu8dHd35/TTX59ly5bkoYceyJFHvihJcuONc7J58+Ykyfz5t2fSpEl5/evPzic+8ZfCRgAAoOOEjTThySTfTjIxyfFJFiZ5ZynlqCQfqbVuTZJSyvlpBYv7JVmR5Ly0gsqvJtm0wzVHt687KskHkyxP8mQp5TeT3GqFIzCSnXLKabnhhuuTJCeddHKS5Mknn8yWLZszZsyYHHTQQVm6dMn2/uPHT0iS1HpfjjrqmNx11/wkyamnnpGtW7cmScaOHTeUQwAAANgpz2ykCfunFQy+NcldSW5PclWSVduCxrZra61/l2R8kiuTrEzylVrr8lrrlh2u2ZXkZWkFmI+3P/9RknPTCioB9irXX//DvOIVr0qSHHnki3LKKacnSZYuXZIZM2YmSRYteiSHHnrYU85bv/6JfPrT/z1nnHHm0BYMAACwE1Y20oQDkjzY/vySJMcmWZWnh9mzSinr0toS/c4khyTpLaVMTPJQrfV7SVJKeWeSlyb51yS/m+TlSWqS/5Hk39daNzyvowF4nvX1daera1z6+v7t3VcLFz6YCy5411P6XXXVVfngBz+QAw/syW233ZYzzzw1GzduzMSJEwad251PfvLj+fjHP57XvObl6e3tfd5rh+HOPGWkMFcZCcxTRgLzdHgRNtKEA2qtvyylTEoyKUlPWlulf7VDv+4kNya5pta6+ZkuVmv9RillUZI1SR5J61mNW5JMydO3WwOMOCtW9GfDho1ZsaL1aNuBgYEsWfLo9uMkuffeu9PV1ZOurilZsaI/Dz+8NCtXrs1jj63Kgw8+nDvuuDc9PZMzZszoTJw4KQcffGiuvXZuzjzz7Oet7r6+7qfUCMORecpIYa4yEpinjATmaWeMHj0qvb2Tdv7dENfC3ml8++enaq3/I8nGJP9Qa/3bHfp11VqX7ipoHGRckuOSTB50jzcl2VhK6WqgZoBhY+HCRzJ+/Pjtx+vXr8/ixYtz3HHHZ2BgQ+bPvzOnnXZGTjrp5Bx77HE5+OBDMnPmobnmmh/klltuTpI89tiqTJ8+o1NDAAAASCJs5NfUXs24un34R6WUcWk9U3F0KeX/KqVMfuazd3q9saWUt6T1Rutra61Lk2xNcn+SryS5PMmJjQ0AoANuvHFObr/9Z7n11nlJkjFjRqenp2f79z/4wfcyd+6P8rGP/Vk+9KH3b/9uYGBDbrxxTu655+48+uijOfvsc/L446tz/fXXpru7J0cddfSQjwUAAGCwUdveYgnPRSllVlovg3lXkuvT2pp/Tq31/5RSpiT5YK31k6WUE5NsrrX+fDfXG53k+FrrHYPaPlVr/S/tz+OTfCLJ/7OHz248PMmCiy6eneWr1z/7AQI07IpLZo3YbR62qDASmKeMFOYqI4F5ykhgnnbGoG3URyR5ePB3ntnIr+vOJBOSfLvW+qtSyplJjkqSWuvjST7Z3vbcW2u9dncXa7+V+o4d20spP2l/XJvke2m9/RoAAACAYUTYyK+l1vrIDsfXl1Lm7tBt454Ejbu4x395rucCAAAAMHQ8s5HG1Vo37XC8Jy+EAQAAAGCEEzYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI3wNmr2CZd99JxOlwCQJNkwsGn3nQAAAEYoYSP7hFWr1mXLlq2dLgOeUV9fd1as6O90GQAAAPBrsY0aAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGjE2E4XAEOht3dSp0uA3err6+50CfuUDQOb0r92fafLAAAA2KsIG9knXHTx7CxfLVQA/s0Vl8xKf6eLAAAA2MvYRg0AAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0wtuo6YhSypQkr6+1fmcn3/Um2b/Wuqh9vF+SA5IckmRarfWaoawVAAAAgD0jbKQjaq2Pl1KeLKUcmmRGkiOSfKvW+mSS/iQ/K6WsSjIqyUCSx7f9KaXUWuuCzlQO7G2uu252zjrrnCxbtjSf+tTFmTJlcpLkIx/5i0ycOClJsmDBQ7nhhutz4YXvywMP3J9PfOJjOeywF6S/f11mzXp7Tjzx5Fx55XczY8ah2bRpY84665xODgkAAKBjhI0MqVLK+WkFi/slWZHkvCRdSb6aZFOS1FqfLKX8bZL/mWRzrXVr+9wLaq3/1JHCgb3STTfNzVVXXbk9HHzve9+f448/4Wn9brxxTjZv3pwkWbt2TT772c+nq6srs2dfk1NOOT1f/eo/5eyzz83BBx+SL37xsvT396e7u3voBgIAADBMeGYjQ+3aWuvfJRmf5MokK5N8pda6vNa6ZVC/rUk2Jzm3lLJfKeVlSVYPfbnA3uyUU07LtGnTdtmn1vty1FHHbD8+6aST09XVlSeffDJbtmzOmDFjsmzZ0vT2HpAkmTatN/fee/fzWjcAAMBwJWxkqM0qpbw5ybok70xyYpLfKKX8p1LKrEH9trZXNM5OclGSN9Rarxz6coF9yU9/Oi9f+9qX87nP/f32tkWLHsmhhx72tL7XX//DvOIVr0qSzJx5WO6/v2br1q255567snbtmiGrGQAAYDixjZqh1p3kxiTX1Fo376Lf1vbPiUn2T7K+lPKCWusjz3eBwL6jr687XV3j0tfXnUmTDst73vO7mT59ei699NIMDKzJL3/5y5x55qnZuHFjJk6ckL6+f9savXDhg7nggnclSd73vvfk8ssvz8qVS/PCFx6eGTMOfErfvcneOi72LuYpI4W5ykhgnjISmKfDi7CRodZVa126qw6llNFJtpRSZiY5M8klSbYk+WQp5dO11uVDUCewD1ixoj8bNmzMihX96e/v3942ceKUPPDAoqxatTIrV67NY4+tyoMPPpw77rg3M2cemoGBgSxZ8mhWrOjffq1Zs347SfKZz1yanp6+p3y3t+jr694rx8XexTxlpDBXGQnMU0YC87QzRo8eld7eSTv9TtjIcDQqrdWMB9Vav7StsZTysdj6DzxPrr76ikyfPiOnnHJ6Vq5ckVNPPT3HHvvSJMmyZUvzyCMPZ+bMQ5MkCxc+kvHjx28/d8mSxVm0aGFe/erX5oknntjeDwAAYF8jbGTIlFJOTDJ3D7oemuRdSU4ppeyXVvA4Jq0Qcnwp5Wu11v/+/FUK7CtuvHFObr/9Z7n11nk5++xzc9NNczNnznWZNm1apk5tvThmYGBDbrxxTu655+48+uijOfjggzNmzOj09PRsv864ceMyd+6PsmjRwpx33vmdGAoAAMCwMGrr1q277wW/plJKV5JTaq3X7kHfCUmOT7IsrRfJ9NdaNz3HWx+eZMFFF8/O8tXrn+MlgL3RFZfMst3iWbJFhZHAPGWkMFcZCcxTRgLztDMGbaM+IsnDg7+zspGhsnFPgsYkqbUOJLn1ea4HAAAAgIZ5/h1DYjdvngYAAABgLyBsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABoxttMFwFC47KPndLoEYJjZMLCp0yUAAADsdYSN7BNWrVqXLVu2droMeEZ9fd1ZsaK/02UAAADAr8U2agAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEcJGAAAAAKARwkYAAAAAoBHCRgAAAACgEWM7XQAMhd7eSZ0uAXarr6+70yXsVTYMbEr/2vWdLgMAAGCfImxkn3DRxbOzfLXQAfYlV1wyK/2dLgIAAGAfYxs1AAAAANAIYSMAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhI0OulDKq0zUAAAAA0DxhI51wbinl4D3pWEr5rVLKQc93QcDe67rrZidJli1bmg9/+IP52Mf+LB/72J/lV79alyS57LLP5Rvf+Gr+5V+u2ul5SbJ58+ZceeX3csMNP8oXvvAPQ1c8AADACDO20wWw7yildCV5W1rz7vdKKbckOSzJgUkeT9KV5Mu11l8N6n9UrfWb7cDx4Frr/E7UDoxMN900N1dddWXOOuucJMl73/v+HH/8Cdu/r/W+TJgwIe9857vzqU99PGee+YaMGzfuaefdeuu8dHd35/TTX59ly5bkoYceyJFHvqgTQwIAABjWrGxkyNRaNyS5M8nNSfZL8pMk1yRZm+RLSb63LWhs+2CSx0opFyS5JMmqIS0YGPFOOeW0TJs27Rm/nzfv5hx33AlJkhkzDs29996z0/MOOuigjBkzZvvx+PETnp+CAQAARjgrGxlqxyc5IklfkjcmOS3Jw0l+N8lBaYWKKaW8N8k3kjyW5M1JvpvkLaWUH1vdCDxXP/3pvPziF3dnzZo1+cAH/igrV67M1KlTkiQ9PT1ZtWrlTs878sgXbV/JuHTpksyYMXOoSgYAABhRhI0MtUOS/K8kb6m1Xtl+duOKJFcl+f0kKaWckeT+JB9OcntaAeX/TvLytIJJgD3S19edrq5x6evrzqRJh+U97/ndTJ8+PZdeemkGBtZkv/3GZerUie3vJ2Ty5P3S19edJNvPG+yqq67KBz/4gRx4YE8nhjMs7Pg7geHIPGWkMFcZCcxTRgLzdHgRNjJk2m+hXpfkvCT9pZT9218dlmRLkk3tPrekFUr+S6312na/RUneWGtd04HSgRFqxYr+bNiwMStW9Ke/v39728SJU/LAA4syceLkLFiwJN3dfVm6dHn6+mZkxYpWv23nbXPvvXenq6snXV1TntK+L+nr695nx87IYZ4yUpirjATmKSOBedoZo0ePSm/vpJ1/N8S1sG87JMmGJPcmmZrWC2G6220TkzxZa91aax1o939TKeX9ScYn+e0kD5VSxjz9sgC7d/XVV2T+/NuTJCtXrsj06dPzqle9Nnff/fMkyeLFi3LMMS/d6bnr16/P4sWLc9xxx2dgYEPmz79zqMoGAAAYUaxsZCiVtLZFD6QVIM5Ickf75/gk83bof3Wt9dqnXaSUF9ZaH3yeawX2AjfeOCe33/6z3HrrvJx99rm56aa5mTPnukybNi1Tp7b+3HLLTfnGNy7PiSe+PGPHjn3aea985avzgx98L3feeUduvvmGLF26JH/+53/ZuUEBAAAMY8JGhtJ+SUYlOTrJV2uta0spv5fk60nObPd5oP3zySSHPsN1XphE2Ajs1qmnnpFTTz1j+/Fb3/r2p/X5/d//g92e9453vCvveMe7no8SAQAA9irCRoZEKaU3ySNJHq213lNKmVxKOSvJd2utG5P8SynlHaWUCbXWgVrr0lLKa0spvznoMlvTerbjPUlmD/0oAAAAANgVYSNDota6KsmqQU1ra63X7dDnn3c4fvpyIwAAAACGLS+IoSNqrVs7XQMAAAAAzRI2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACN8DZq9gmXffScTpcADLENA5s6XQIAAMA+R9jIPmHVqnXZssULsBm++vq6s2JFf6fLAAAAgF+LbdQAAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCPGdroAGAq9vZM6XQJkw8Cm9K9d3+kyAAAA4HkjbGSfcNHFs7N8tZCHzrriklnp73QRAAAA8DyyjRoAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLdR0xGllN4kTyaZkWRlrXVlh0sCAAAA4NckbNzHlVJGJ3lxrbUOOp7c/jMjyZha69wdzpmS5PW11u/swfWPqbXe2/58fJJ7aq2bkqxN8v8m+VqSNyT5amODgmFqzZo1ufzyL2fGjEOzadPGHHPMS/OpT12cKVMmZ8KEcfnwhz+SrVuTH/7wmvT2HpDHH1+dt7717dvPv+662TnrrHM6OAIAAADYNduo93G11i1JvlVK+Ukp5ZYkc5J8MclfJvnD7GSO1FofT/JkKeXQUsqrSynvLqWMf4ZbvHLQ50eSfKp9jY1JFiYZSLK2lDJjxxNLKQfspK1rz0cHw8vXv/71nHnmG3L66a/P4sWLsm5df9773vfnr/7qv+XTn/50Jk6clGuuuTJveMMbc9ppZ6SnpycPPfRAkuSmm+bmqquu7PAIAAAAYNesbCRJ/k+Sryd5bZJRSZYmWZNkYlpbnZMkpZTzkxyRZL8kK5Kcl6QrrVWJm3a8aCnllUl+su241vp4KeW/lVIOSnJukpOT7J+kt329JTtc4g9LKQ8lmZRW6DkmyRtKKb/ZXh0JI8rixYvT29vK0KdN680999ydI4544VP67L//xMybd3POPvvcrFmzJhMnTkqSnHLKabnhhuuHvGYAAAB4NoSNJElqrY8m+XYp5f1JfprksSQnJlk3qNu1tdYNpZSPJrkyyWlJbtjF8xaPqbV+IUlKKVOTnJDkzCSfSSug3JxWGHlkkvWllDG11s2Dzl+V5Du11ie2NbT7CBoZkQ4//PDcf3/N0Ucfm3vuuSszZszMT386L7/4xd3ZtGlDfu/33pdzzz0vH/3oR3LrrfNywgkn5aCDDu502QAAALDHhI0kSUopp6S1uvGgtFYQ/kmSe9La5rzNrFLKurQCyHcmOSRJbyllYpKHaq3fG3S9o5PcO+jc8Wltm74/SV+Sd6X1XMgDkkxNcmOSxUlWDzrnycFBI4x073rXu3L55Zdn5cqleeELD88xxxyTl7zkJZk+fXouvfTSDAysyRNPPJHzzz8vXV1d+fKXv5x3v/sdGT++9ZSCrq5x6evr7vAo2NeZg4wE5ikjhbnKSGCeMhKYp8OLsJFtfpzkPyZ5RZJfpLVy8ZQkGwb16U4rFLxmhxWIO/PqWus/bjuotf4yyS9LKS+ttf68lHJCkv+dVmA5s9Y6Z3cFllLGJNm4pwOC4Wb//ffPrFm/nST5zGcuzZgx+2XDhmTFiv4cfPDBeeCBRbnpphty0UUfyNixY7NgwaJcddW1ed3rTk2SbNiwMStW9HdyCOzj+vq6zUGGPfOUkcJcZSQwTxkJzNPOGD16VHp7J+38uyGuheFpVK11S631m0keSGtr88lpPbNxcNjYVWtdurugsZRyaFovg9mZ7vaLX56otf4qrVWUu1RKGVVK6U5rG/by3Y4GhqlFixZl3rwfJ0meeOKJ/Pznd2b+/NuTJMuXL8/06dMzadK//c26r+/ATJgwoSO1AgAAwHNhZSNJklLK6WltaV6e5MAkjyZ5cZLnso35rG3Pahx0/X+X5PfSehbk2LSe2Zi0Xv7yTF5VSvn3SbYk+VWS/iT//BzqgWFh3LhxmTv3R1m0aGHOO+/8HHzwIbnpprmZM+e69Pb2ZurUaTn//Fm55por09MzJb/85aP5rd96d5Lkxhvn5Pbbf5Zbb52XV77y1R0dBwAAADwTYSNJ8o4kZ6f1lumxaa14HZvWMxMvTZJSyolJ5u7uQqWU3rRe7LKjy5N8JcmUtFYofri9LXpJkvmllOlJxtZaFw4659pa6x88xzHBsHPwwQfnIx/5i6e0vfWtb0/yb0v/J0+ekvPPf9vTzj311DNy6qlnDEGVAAAA8NwJG0mSv01yVZL1tdYt2xpLKWe1f3Yl6a21XrsH1zozybd3bBz0BulVSa5r/0kpZUaS30jyyyRzdjjn6892IAAAAAB0jrCRtJ/VuLP269ofN+5h0PiM19pF/yVJ/u7ZnAMAAADA8OQFMezWHrx5GgAAAACEjQAAAABAM4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI7yNmn3CZR89p9MlQDYMbOp0CQAAAPC8EjayT1i1al22bNna6TIAAAAA9mq2UQMAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRjb6QJgKPT2Tup0CXuVDQOb0r92fafLAAAAAIYZYSP7hIsunp3lq4VjTbniklnp73QRAAAAwLBjGzUAAAAA0AhhIwAAAADQCGEjAAAAANAIYSMAAAAA0AhhIwAAAADQCGEjw14pZVSnawAAAABg98Z2ugD2TaWUFyYZl2RTrfWBUsqFtdYvPEP3D5RSZtdaHxq6CtmVxYsX5yMf+bNMmTI5SfKRj/xFvva1r6S7uyeTJ0/OueeelyS57LLPPa3t2mv/JaNGjcqdd96RP/mTP+3YGAAAAIDmCRsZMqWUMUlOS3JKkp8meSDJoe2f++3Q9zVJfpGkO8l9Sc4tpQwkmZzkG7XWJUNYOjvx3ve+P8cff0KSpNb7MmHChLzzne/Opz718Zx55hvy0EMPPq1t9erHsm7durztbb+ZJ598Mlu3bs2oURauAgAAwN5C2MhQOjStkPHIWus1pZQXJBnT/m7jDn3HJ/mDJPsnmZfkyiSvqbV+fqiKZc/Nm3dzTjjh5UmSGTMOzb333pM777ztaW33339fjj32uCTJm950fsfqBQAAAJ4fwkaGRCllbJIz0goRX1dK6U0reHx1KWVGklNKKfsl+V+11o1pbbFeluTwJK9N8pokh5RSDkrytVrriqEfBYP99Kfz8otf3J01a9Zk3bp1mTp1SpKkp6cnq1atzMqVK5/WtmzZsmzcuCnz59+RRx99NB/+8J9Y2QgAAAB7EWEjQ6LWuqmU8tVa60ApZXNaKxXPTWur9HeTjK21XjbolMlJFqS14vGhJC9P8vVa6y+GtnJ2pre3N+95z+9m+vTpufTSS7Nw4UOZOnVi+vq6M2nShEyevF/222/c09q2bt2Yl73s6Jxxxhn55je/mYUL/zUnn3xyp4czbPT1dXe6BNgt85SRwDxlpDBXGQnMU0YC83R4ETYylF5cSjk8yeuTTEvyj2mFiFN30veAWuu3SimvSvKyJP+aZGCoCmXXNm7cmA0bkhUr+jNx4pS88IUlCxYsSXd3X5YuXZ6+vhmZOHHy09omTJiYCRN6tp/3wAOP5AUvKJ0ezrDQ19edFSv6O10G7JJ5ykhgnjJSmKuMBOYpI4F52hmjR49Kb++knX83xLWwb9uQVsj4p0kWJ9mc5PwkJ+6k7/pSyui0XigzNsnJSf6mlGLP7TDw7W9/O/Pn354kWblyRV71qtfm7rt/niRZvHhRjjnmpTttO/74E3PfffcmSVatWpXDDntBZwYAAAAAPC+EjQyl9e0/JyRZnVbYeE2t9YeDO5VS9k/yRK11S5LZaa1o3C/J79Vatw5pxezU+eefn8ceeyxz5lyXadOm5dhjX5qBgYF84xuX58QTX56xY8fmqKOOflrbK1/56ixf/svMmXNdNm3alBe/2KpGAAAA2JvYRs1QmpDk1UmuSfLzJKOSvLKUMiGt4HGbNyf5Xvvz+iST0gonJyZ5Ysiq5RkdcMABeetb3/6Utt///T94Wr8d20aPHp33vvf9z2ttAAAAQOcIGxkytdaHSil/XmsdSJJSygFJ7kpr9eJL2m09SRYmOaKUckSStbXW/9n+7t+XUvqS3Jbkh+23VgMAAAAwTAgbGVLbgsb255VJ/rl9eHu7bW2Sn2zrssO5/6uU0ltrXTUUtQIAAADw7HhmIyOKoBEAAABg+BI2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACN8DZq9gmXffScTpewV9kwsKnTJQAAAADDkLCRfcKqVeuyZcvWTpcBAAAAsFezjRoAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaISwEQAAAABohLARAAAAAGiEsBEAAAAAaMTYThcAQ6G3d1KnS9hrbBjYlP616ztdBgAAADAMCRvZJ1x08ewsXy0ga8IVl8xKf6eLAAAAAIYl26gBAAAAgEYIGwEAAACARggbAQAAAIBGCBsBAAAAgEYIGwEAAACARggb6ahSyi7nYCllbCll/FDVAwAAAMBzJ2xkyJVSXlZKeVH7cHIp5QO76L45yR8PQVk8BwsWPJQvfOEfsnbt2lx++Zdyww0/ynXXzU6SrFu3Lt/5zj9n7tw5+f73v/OMbQAAAMDeQ9hIJ/wqyaHtz2uSDJRSugd3KKUcmiS11q1JHiilHDLou1cNVaHs2o03zsnmzZvz/e9/O2ee+Yacfvrrs3jxovT39+eaa67MG97wxpx22hnp6enJQw89sNM2AAAAYO8xttMFsO8opYxK8q4kRySZWkp5YZJxSV6ZpKeU8s+11qXt7h8upUxMMi3J1CT/VyklSbqS/FOSnwx1/TxVrfflqKOOyV13zc+yZUvT23tAkmTatN7ce+/d2X//iZk37+acffa5WbNmTSZOnLTTNgAAAGDvIWxkyNRat5ZSvpvkoCSvSPJoktVJltVav7utXynl5UmWJLklyYIkq2utT7a/O7HWescQl85OLFr0SI499rjcddf8zJx5WO6/v+boo4/NPffcla6urpx77nn56Ec/kltvnZcTTjgpBx108E7bAAAAgL2HsJEhVWtd316heGiS+UlGJdmwQ7clSf42ye8lebTW+sskKaW8p9b6xSEsl2ewcOG/5swzT83GjRszceKEXHTRe3L55Zdn5cqleeELD8+MGQdm7drlOf/889LV1ZUvf/nLefe735GHH374aW3jx3v/zzZ9fd277wQdZp4yEpinjBTmKiOBecpIYJ4OL8JGOuUFSc5Osiyt1Y3b1VofTZJSyrok/aWUlyR5S5J7Simj2s9xpIMefnhpVq5cm8ceW5UHH3w4tT6cWbN+O0nymc9cmp6evnzjG9/ORRd9IGPHjs2CBYty1VXX5u67f/60tte97tQOj2Z46OvrzooV/Z0uA3bJPGUkME8ZKcxVRgLzlJHAPO2M0aNHpbd3549GEzYypNrPbexJcleShWk9r3FKKeWVaT2P8a9rrQPt7hOSvC3JQ7XWSzpQLs/gtNPOSJIsW7Y0jzzycEaNGpV5836cV7/6tXniiScyc+ahmTTp3/6m09d3YCZMmLDTNgAAAGDvIWxkSJRSxiS5IMmYJCuS9CW5JsniJAtrret2ctr4JF+qtW4cdJ3X1FpvGYKS2Y2BgQ258cY5ueeeu/PmN8/K3Lk/yqJFC3PeeecnSc4/f1auuebK9PRMyS9/+Wh+67fenRe/+CVPawMAAAD2HsJGhkStdXOSL5RSxib5T0nm1VoXt1c6/l4ppS/J52qtvxp02tYkBydZNKjt8LReHEOHTZjQlXe+83fyznf+TpLkIx/5i6d8P3nylJx//tt22wYAAADsPYSNDJlSyouSnJDkM9tCxfbzF/+plPKaJCXJ7YNOuTbJV0sp257RuDHJr0opV9Va1wxd5QAAAADsCWEjQ+nBWusDO/tiZ1uja61Lk5z+vFcFAAAAQCNGd7oA9h3eIg0AAACwdxM2AgAAAACNEDYCAAAAAI0QNgIAAAAAjRA2AgAAAACN8DZq9gmXffScTpew19gwsKnTJQAAAADDlLCRfcKqVeuyZYuXYQMAAAA8n2yjBgAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABohbAQAAAAAGiFsBAAAAAAaMbbTBcBQ6O2d1OkShqUNA5vSv3Z9p8sAAAAA9hLCRvYJF108O8tXC9V2dMUls9Lf6SIAAACAvYZt1AAAAABAI4SNAAAAAEAjhI0AAAAAQCOEjQAAAABAI4SNAAAAAEAjhI0AAAAAQCPGdroAnq6UclyStbXWR0oppyX5Va31tt2cc2ySg2qt1z/Le41KMr7WOvDcK25WKWVykidqrRs7Xcu+YsGCh3LDDdfnwgvflyS57rrZOeusc5IkDzxwfz7xiY/lsMNekP7+dZk16+2ZMePQp7WdfvqZnRwCAAAAMAwIG4enLUlmJHkkydlJvlFKeX2SI5PcWWu9rR0Svi/JNbXWRUnekOT/lFKmJxlVa12yu5uUUnqSvCXJ15ssvpTy0iSvrLV+/jleYm2SC0ops2utjzZYGs/gxhvnZPPmzUmSm26am6uuunJ72Lh27Zp89rOfT1dXV2bPviannHJ65s+/42ltAAAAALZRD09jk4wvpZyc5F+TTE+yKMn3tq1wrLVuTfKlJKNKKYe2+1zQbtu6uxuUUkYn+b+SfK3Wuqnddkkp5UPtzy8opSwqpcx4NoWXUg5L8qokh+1h/7JjW3ts/5Tkj0sp45/N/Xn2ar0vRx11zPbjU045LdOmTdt+fNJJJ6erqytPPvlktmzZnDFjxuy0DQAAAEDYOMyUUn4nyUeTvDLJy5LMTPLyJOck+R+llDHtPwe0tz7vn+T8JD9PcneSf6i1Lt2DW70tydxa6+ZBbdcnOaH9+YQkP9+TFZKD1VoXJrluT/q2g8Q/fYbrbE3y3SQXPZv78+wtWvRIDj1099nw9df/MK94xat22wYAAADsu2yjHmZqrZeXUmYlmZbkH5O8KcnDSTYkWb8tHCylvLWUcl2SU9JaBXhAks8m+Z09vNU5aa1sHGwg/zYnRifZ2L7X4Wltt16WpLfW+rlSyqlJ/izJ/0gyOcnv1Frf/kw3K6X8+yQPprXicV6t9Z60VkDOKKWcnWRlrfXOHU77WZI/bo+L58Ftt92WM888NRs3bszEiRPS19edJOnqGrf98zYLFz6YCy54127beO52/J3DcGSeMhKYp4wU5iojgXnKSGCeDi/CxmGm/aKXeWmtUnxbkte1j8ckeXl7NeBltdbPl1JOT2v1X1+SWWmtcLyolHJLrfWu3dxqTJInd9L+SCllZlrPjdzmz5N8qNb6ZHur9UG11htLKWel9VKafyql/GAXYzorrRe+/LD9rMnPJ/n99jWW1Vqv3dl5tdYttlE/v1avXp2VK9fmscdW5cEHH84dd9ybmTMPzYYNG7NiRf/2fgMDA1my5NHdtvHc9fV1+10y7JmnjATmKSOFucpIYJ4yEpinnTF69Kj09k7a6XfCxuHnZUluTfJ4WisB16S1wvAnaQV2/zio75FJxqW1SvFnSd6f5PAkh7bfaH1FrfWZ/hf3syRHpRVqDnZzkncm+dGgtplJXtt+vOJDaW3d3ubGJKm1PrGLMZ2UZG6739ZSyh79J4f28xzrnvTluTn77LOzYkV/li1bmkceeTgzZx66034LFz6S8ePH77YNAAAA2LcJG4eRUsohSa5IK5zbnOTQtN5KvSGt7dHHtVcGfiOtrctT03qT9IuS/DjJiiQfqLVeuge3+2Ja26B3DBtvSfI3aW2P3uaXSW6utW4spfwiyWPPcmjz0wpBf9I+XjvouyfbL6s5OMmKWuvGQd99MMnHn+W9eJYGBjbkxhvn5J577s6jjz6a+++/L7ff/rPceuu8vPKVr06SjBkzOj09PU85b2dtAAAAwL5t1Natu31xMUOslHJO/u05jfunFQovSfKuWutn233+NMlPaq1zSikfSHJ1kt4k76i1/sUe3ufQJGcl+WJ7xeFfpPX8xwuTfCXJt9N6ZmRPkt9I8kiSgVrrP5dSXp7Wy11mJ5ndfjFMSilHJnl9knOT/G2t9eZ2+wfaYzowyW211nvb7W9O62U4tdZ6ebttVFpv1r611nrfs/4FPtXhSRZcdPHsLF+9/te81N7niktmWW4+TFj6z0hgnjISmKeMFOYqI4F5ykhgnnbGoG3UR6SV92xnZePw9KskTw4K8EYl+ask3xnU52/yb28TH5PW26MfS/KVUsqo9tucd6nWuqiU8pUkk5L011o/0f7qv7Z/Ht/+uTTJJ3c497a0tlvveM2H0tpqfdkO7Z97hhp+kGTH5z12J/nqDqscAQAAABjmhI3D0LbVgIOOt5ZSPjY4QGy/lXpz+/Nnfo17bUz7rdPDRa117e57AQAAADDcjN59F4aDPVmpCAAAAACdJGwEAAAAABohbAQAAAAAGiFsBAAAAAAaIWwEAAAAABrhbdTsEy776DmdLmFY2jCwqdMlAAAAAHsRYSP7hFWr1mXLFi/0BgAAAHg+2UYNAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRibKcLgKHQ2zup0yU87zYMbEr/2vWdLgMAAADYhwkb2SdcdPHsLF+9dwdxV1wyK/2dLgIAAADYp9lGDQAAAAA0QtgIAAAAADRC2AgAAAAANELYCAAAAAA0QtgIAAAAADRi2IeNpZRRv+b50wZ93m931/t17wcAAAAA+6qxnbhpKWX/JFOSTEtyYPtPT5JRSSYk2Zzk/9Ran0yyfynl92qtn2ufe06tdfZurn9MrfXe9uGoUsqnkvxlkiOTXFBK2ZrkulrrtTs5/QOllC/VWp8opRyU5OBa6/w9GFNPksOSvCHJ39Zat+zunPZ5XbXWDXvS9/m0w++so0opo5NMqbU+1ulaRpI1a9bkiiu+n3HjxmXLli0577y3JEkWLHgoN9xwfS688H3b+1533eycddY5SZK1a9fmyiu/mxkzDs2mTRu3twMAAAA8W0O+srEdJL0ryauTTGz//H6SLbXWz9VaL621/n07aEyt9VdJNg26xAOllA/u5jav3Pah1roqyXeS7JfkV0lmJ7khyeJnOHdjrfWJ9rm/TPJbpZT9nmEs55VS/kMp5Q+TnNce16PPImg8K60A9HlVSvmt3Xw/JslJu/i+p5QyZAlU+/d3QinllbvtzHY//elPM2nSpLzxjW/OHXfctr39xhvnZPPmzduPb7ppbq666srtx9///rdz5plvyOmnvz6LFy9Kf3//EFYNAAAA7E2GPGystW6ptX4+yY211p8kWd4O9yaUUl5QSvmNUsrkHU7bOuj8h5J8r5TSVUo5ZMfrtwOqn+zQvLTWujpJSfLz9vXGPUOJW3c4/l+11vWllJmllKesBK21XlVr/bu0wtJ7ksyttX51V+MfVOfrk4wevJqwlPKGUsr5pZQ/KqX8eE+uswf3mZHkot10e1OSq9v9Z7Vr+M+llO+2v/+DJNOf4frvLaX8TRO1DlZrvT7JyaWUFzV97b3V2WefnTPOOCtJMnZsa3rXel+OOuqYp/Q75ZTTMm3a9qcLZNmypentPSBJMm1ab+699+4hqhgAAADY23RkG3XbH5dS7ktyUinlXUmOTXJfkjOTXJEkpZT3JDkgrVVuNckhSSanFZKemuSrSZbtcN1jaq1faJ9/YVor9mYk+c0k02qtK9vX+mYpZXOS36q1LiqlHJrkPUleWkoZn+T6JGck2VxKeV2SW9IK5Ha2InJdkt9oB49p33tMrXXzTvpu85u11g/t0PaqWuvF7fPn7eLcPVZrXVJKeXQ33XprratKKVOTzKy1/n2SK0sp17e/vy3J4c9w7veTzGmi1p34fJJPJ/nD5+n6e53165/I5z739znjjDOTJIsWPZJjjz0ud931zE8CmDnzsNx/f83RRx+be+65K11dXUNVLgAAALCX6WTY+Eit9SullFG11q+VUibVWq8rpZxUa92YJLXWLyZJKeWPkzyZ5N5a673tMPAFtdarB1+wlHJ0ksHPHfynWusXSikfKqW8NMntpZSXpbVK7/Ja66e3day1LkpycSnlfUluTdKd5Eu11g3tZzd+s9b6ePs+XUmOTisI3RaAntbeIr71/8/enUfZVZV5H/9mIgmpjEWFEKYwPmDEBFCQIRAEmYwCLdI4tDKodIu2rxPdKt2+Ctq8Kj04tKKioAiKs0FExpAAIvOMD1OAAAmZkwpJKqmk3j/OqXgpKkkFTqVyk+9nrVr3nnP22Wefm81ird/aAzCAYnTlzZ29eDkic2knl8a0r0mZmXeXZd9AEbodBbyNIpT9L+DtwGHA74CDgWnAQ2WZBylC269n5mJgq4j4ELA1MLg90CzrP5IiWAVoBiZExF2Z+Zf2NpTeXL7fIcCXMvOZctThu4EZwFNlfccC5wFnAXsAb8vM90fEp4F7y99rQWb+ISI+AcwDXgTOBY7KzJaaf5PlZQCqLtp551F85Svncd555zFy5DDe8pYJrFy5kkGD+tPUNHhNuQED+q05/uAHP8Dll1/O3LkvsNtuY9h++5EvK6uNx99d9cB+qnpgP1W9sK+qHthPVQ/sp5uWngwb260oP4dGRCM16zOW4dbJwM7At8rvjwCvB67ppK43Z+aP2g9qRxZm5kMRcTwwHZgF9Ol4c0TsAhxBEb7NpAj4rgKWtAeNZV3LI6J/Wdet5WYyvTPzf7r4zn2BzjaF+SfgjIj4BfCtzLw5Mx+IiKnAyvLvS+WGMj8sQ9iPUYwE7U0xTfyq8v0OAcYDU8t3/VFmtkbEJR2euVNm3lC+V2sZtv5TGQR+OTMfLMs9nJk/jIhngUMpwuInImIaNaMeM/OacqTqoMz8eURMLnf4zvJ33RX4PPAH4NrMfDgizgE+Vxs01nB38C5atGgRCxYsZdCgBkaN2pHp059nwYKXmD9/Hk8++TT33vsIO+ywIwDLl69kzpy/rc14wgl/D8D//u83GDKk6WXXtHE0NQ32d9cmz36qemA/Vb2wr6oe2E9VD+ynPaN37140NjZ0fm0jt6VWW0QcBtxSHt9FEZCtgjU7Vp9fnn+k3DSktRxNtycd1mUsp0E/s7aHRcQ4ipF/+wJHZOYfOlw/HjgamJKZT2XmMopRhAALO9aXmbdn5hPtm8nQSXi5NuUoymGdnF9Z7rr9XuDsiBhVXvotcCzQr8PO1fdlZnNmtpYb6rwI/ANwOEWY2f7vuywzazfZaX/nA4GXTdfOzCWZ+TXgw8B/lKNIoRj1CEUYvLb1LmvrmVZ+Ls3MNopA8t3AVu3tKoPGvYBt2st3aF9fyv6g9fvtb3/Ln/98KwDz589j9Ojt2W+/NzJ27D6MGrXdmqCxo+eff47bby+WCF26dOlay0mSJEmSJK1PT4aNAI9m5gsAmXkzxWjFfuXx0sz8XLkhTPvotrspdq9uaZ9qXePIclORzkwARmXmsxRTexd2LFBu9nIRL98gpm9E7ECx+csrRETvcidngC7tQF3jL+UU6fa6+kbE35VtWQHcSjFNG4op0ofxt8BvbT4D/DQzr6GYntyrpn2deV1mPlrThh0j4qCyDYsp1tB8zQv4RcRYYGRmXt7+vIjoV45c/Tfgi+XxQR1uPRO46LU+f0vxtre9jYULF3DjjdczePAQ9tprb1paljNt2hQefvghZs0qlu6cNm0K99xzF3fcUeTM/fr1Y+rUm/jFL37G8cdP6qnmS5IkSZKkzUBPTqMeCfwgIoYBjcAoio1Wvt9eoFzbcC9gdTnKbwDFBi1vL0PAAcD/lp/zOntIRIwErgOui4jTgYuBbSPifZl5WYeyxwJDImIwMBy4FjgdmB0RE4EHM/Pa9vKZuToijis3nOm4i/U6letVnhIRKzLzr+UU5n+JiF2BJ4GVmflQWbYtIpZSrgFZrmN4MLBrREzMzClltTcC746Ih8rf83XAo8CeZb0vld93A/rzyhD1eeCGiPhvYDZwf2Yujojx/G2q9HiKqdCXlKNMDwFGRcTdmflguZnOLhExCbgjM2dTrOnYFBEnlXX0BQ6gGGX6dPkuJwPfaG9I+Xs/XYbQ6oJtttmGk08+9WXn+vcfwCmnvIdTTnnPmnMTJkxkwoSJa45HjtyWc875/MZqpiRJkiRJ2oz1amvboIysMhHx78ADFKHWHGAusIxihOIfasr9I/AYMJBiavBMYFZmzq8p8y7g12vb/blcC/JNwM3l9GjKMOxNwFWZeWd5bhjwVYrp2/sDL5TPe3Et6wm21/8JilGana0jub7fYUTtu6yj3Lsy8xcbWv866js1M39WVX1VKkc8DuvK79IFY4DpZ55/LbMXLKuguk3X5AtPcJ2KOuY6I6oH9lPVA/up6oV9VfXAfqp6YD/tGTVrNu5CMZBsjZ4MGwd0WH9wXWV7l2s2drtX+6zuamO5ac3XgQvaQ1FtkDEYNqoO+D9I1QP7qeqB/VT1wr6qemA/VT2wn/aMdYWNPTaNuqtBY1l2owSNr+VZ3dXGzJwOvLM76pYkSZIkSZKq1NMbxEiSJEmSJEnaTBg2SpIkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSapEj20QI21MF597dE83odstb2nt6SZIkiRJkqQtnGGjtgjz5i1h9eq2nm6GJEmSJEnSZs1p1JIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRJ9e7oB0sbQ2NjQ001Yr+UtrTQvXtbTzZAkSZIkSXrVDBu1RTjz/GuZvWDTDvImX3gCzT3dCEmSJEmSpNfAadSSJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSfTfWgyLibOA7mbl6Ldd3Ao4CWoFBQDPQH3gY+Etmtq3lvr7Ah4CL1lb3Wu7rBWyVmS0b9CLqdhGxTWbO7el2bGyrVq3iqqt+x+DBQ5g+/UlOO+2DAEyf/hQ333zjmuPrr/8TvXr14r777uVTn/oXZs58gQsuOJ9hw4YCcM45n2fQoIYeew9JkiRJkrTl2mhhI7ByHUHj4cCngSFAH6AF+DXQBhwIvA34t7LsEGBP4A3A74CzgNkbGDQOAd4O/HxDXyIi+gHDM3P2ht6rLlsZER8CfpSZrT3dmI3llltuYfDgwRx++BHMnPk8Tz31BLvuujvTpk1h1apVAMye/SJLlizhxBPfyYoVK2hrKzL4M874MOPGje+xtkuSJEmSJEE3h40RMQg4iSI0fHNErKKYuv1cZv6xpuh+wJeA0cAs4PXAA8DuwHxgSk3ZNwLHlOWHlO8wrhw5uSgzL1tPm3oDnwTOy8xVNedPB5YDjcDbM/OYtVTxz8A84JL1vH5lIiIyM7tQ7gRgFbA3cEhmnlhhG74IzM3Mb1ZV59pk5qKI+A3wL8CXu/t5m4rtttuO+fOb1xxvtVV/Mv/KXnu9jgcfvB+AqVNvYuzYfQA47rhJPdJOSZIkSZKktenWNRsz86XMvCwzfwrclpkXAz8GHo+Iw2qK/g+wDNgKGAnMBSYA7wWG1U51zswbgccy8yVgHHAF8Czw3fUFjaUTgakdgsYJwO6ZeUVmfgv4VkT0Wcv9d3fl3atSBraf7EK54cAOmXlVZn4NOK/ipvwQuLLiOteqnEbdEhFjN9Yze9qee+7JoYceDsALLzzP9tvvwIwZz7DjjjutKTNz5kzuu+9efvazy/jv//76mpGNd955Oz/72WVcdNG3e6TtkiRJkiRJ0I0jGyPiTRQjFpdQjFCcGxHfA26iGBm4KCK2zsylFKHnu4D7gYkUwVZv4A/l/bX1Hg+8NSLagDuBwcBuwD9FxEDgr5k5eR1NO5pXhnfvB37UftB+f0R8BHgcGACMLMNSgN0i4lSKEZhXZObDEbEvxajLpRRTxq+MiGMpQr+zgD0opoN/FrisfMfVwM6Z+ZXyef8MPE0xRfybFOtWHgSMiYijKEaE/nUt79UMTIiIuzLzL5l5d1nnm8p2TgfeCvx7+Xv9v8w8KSL2rPn+f4B9MvPMiPgScHdm/i4iXg/8I/BL4MWy3mHA6WV7JwALKKal/y9wKTAQaMvM70fEYOAM4EFgn/K3HtVZ2Q7vdBvwFop1O7cITU2Dufrqq/nIR85ixozHectbJrBy5UoGDepPU9Ng2tpW8oY37M3EiRP5xS9+wbPPPsbYsWP5wAfey+jRo/nGN75BS8sidthhh55+Fb0KTU2De7oJ0nrZT1UP7KeqF/ZV1QP7qeqB/XTT0m1hY2beGRH3AEdQTE3+MUWod0/HKcGZ2RoRoykCsccoQri+5efcDmWvjojRmfnDiDiRYir1PhTr+/2lC03rA6zocG5HYE4nZZ/PzOsiYgfga0B72NiamT8r1378T+CDwMcz8zSAiPhxRPwyM68pQ8lBmfnziJicmUsjYjZwZWa2RMSl5T3HAzMz8/cR8Szwocz8OnB9RLwvM69f10uVv+EHKULXTwBfzswHKTbZ+R2wEjgV2D4zH4uIReV9a74D3wK+U35/IDN/V5Z5KCLu6vDI9wHXldfenpmfLN+jGbgsM9vKd/s+cA7w/cx8NiIeA87JzHPXUrbWCoogcotx881/ZsCAIQwYMIynn76PuXMXM3/+PJ588mnuvfcR+vcfRP/+Q5gzp5lBg4bxxBPPMGLEaICaczPo339oD7+JNlRT02DmzGlef0GpB9lPVQ/sp6oX9lXVA/up6oH9tGf07t2LxsbON6ft1mnUFCP5ZlGEc80UG78siogvR0THNGQ+xTTqZcDJwAEUazMu66TetojYD7iOIky7hGK0YVfe5y5grw7n5gLDOyk7NCJOowhLV9acfwYgMxfX3LdTREyMiIkUI/EGtRfOzGnl59Ly1LKaqeHtu2y/Hmgs79+WcgThhsjMJeUU6g8D/xERWwGzKUYlto+6XOtvVG7G8lI5anH5eh73HLBN+X1RzflFNTuHt3/unZnPls94jr/9/p2VrbU/G3naek9aunQpzz33HPvsM46WluUMHTqM/fZ7I2PH7sOoUduxww47Mm7cvvz1r48AMG/ePHbaaWf++MfJ3H//PQDMnTuH0aNH9+RrSJIkSZKkLVi3hY0RsTPF1N6ZwOL285k5i2IE3T4dbtmWImwcQDFa8FHg0sx8oEO9h1JsJDMTeAfF1N5ewB8p1nhcn0sppmzX+hPFdN32ZxxXjlo8MjMvycz7gdXlTtQA/cpyw4EXynMzM3NKZk4BflqGqxvicWBOWcefKKabt1tVPm/M2m6OiB0j4iBYE4L+leK3/BJwYWbeRPHv0D6atb3OfhSjQ9v9HvgP4Jb1tDeB/SPiaOCi9ZR9LCJGlc/brrx3ncrff9/MvGF9ZTcXv/rVr5g69Sa+8IXP8tGPfpghQ4bQ0rKcadOm8PDDDzFr1iwOOODNzJ79IlOm3EBrayt77BEcddQxzJ8/nylTbmDEiBEMHz6ip19FkiRJkiRtoXq1bzBRtYgYQBFonQ18D9iXYoTbDzopOxA4OTN/EhH9gXdSrNU4gmJjmcfKcr0pAsDrIuJgYHpmzoyIf8zM70bEJ8tnXpKZizo+p+Z5OwJHUoSZbeVmMF+kmEq9CLiPYn3Bb1GMnmwr23QpxejMQ8rrewM/y8wZZXsOoghBF2TmHyPiEOArFFOw78jM2WXo9huKYPSl8vs/UEwh/yzFiME24E+Z2b4+4geBocAT7VObO3mn3hQB439TjGYcWP6eZ1CMspxRtntRZp4fEf9KETbPoAhtP56ZL5S/xTcy8+yaul9PMVryRYrp349HxAE17X0e+DbQBPyUYhOeQeX3v6MYUfk+iinyu5XnOy1b/nsOAT5Q/ju+1rHQY4DpZ55/LbMXdDZIdtMx+cITHPq9BXPov+qB/VT1wH6qemFfVT2wn6oe2E97Rs006l0o9vNYozvDxjHAWOD6cm3CtwCT2tf261C2LxAUYV9QBHMt5bWzKYK46zJzZU35oZk5rzw+KzPXN7qu4zP7AQMqCLO2SGVY+bXMXFVuMvO2zPyviureptyNugpjMGxUHfB/kKoH9lPVA/up6oV9VfXAfqp6YD/tGesKG7ttgxiKzVXWPCwzb4yIqZ0VLNcKbN9xeHaHa99eS/l5Nae+t6GNK4PLlestqLV5EJgUEQsppsD/vqqKKwwaJUmSJEmStBF1527UrwjyypCwO57VPcMztVaZ+YeeboMkSZIkSZI2Ld29G7UkSZIkSZKkLYRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKdOdu1NIm4+Jzj+7pJqzX8pZu2T9JkiRJkiRpozFs1BZh3rwlrF7tpuWSJEmSJEndyWnUkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEn17ugHSxtDY2NAjz13e0krz4mU98mxJkiRJkqSNzbBRW4Qzz7+W2Qs2fug3+cITaN7oT5UkSZIkSeoZTqOWJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVIm6DRsjYvfys29EbB8RR1dcf9+I+KeI2KDfKCJ6RUT/KtuypYmIbXq6DZIkSZIkSdpwfXu6Aa/BvhHxDqAZmAe8Hri2tkBEfAc4GVhdlpsFvAjMBRYCi4H/ysylETEE2BN4A/A74Cxgdmau7mqDyjreDvx8Q18mIvoBwzNz9obeuxlaGREfAn6Uma093Zgq3HDDtRx55NEsWbKE6667hsbGbVi4cAHveMdJzJz5AhdccD7Dhg0F4JxzPs/ixYtfcW7QoIaefAVJkiRJkqT1quewcR5wV2ZOB4iIHTsp8wXgv4HnMvOliOgLrM7M1RExNDMX1ZR9I3AM8CVgCMVvMy4izgYWZeZl62pMOQLyk8B5mbmq5vzpwHKgEXh7Zh6zlir+uXynS9b92tWJiMjMXE+Z7YE/AJ+lCG2PB36fmTd0V7syc1FE/Ab4F+DL3fWcjeWWW6Zy9dVXceSRR3PNNVdx7LGTaGhoYMqUG3jqqScYOHBrzjjjw4wbN37NPYsXL37FOUmSJEmSpE1d3U6jBvoBZ0TE2RHxj8CSjgXKUYKnACdHxEXAHsB3I+ITwI8iorGm7I3AY5n5EjAOuAJ4Fvju+oLG0onA1A5B4wRg98y8IjO/BXwrIvqs5f67u/CMykTEIIpwdJ0y83ng6cz8Y2b+KTM/DjzR3e3LzLlAS0SM7e5ndbdDDz2MESNGALD11oO4/fZbAVi0aJGjFSVJkiRJ0malLkc2lqMIbwP+TDE9um9mroyIvp1Mu20Gfgr0y8xHI+LezPxORDRn5ryaOo8H3hoRbcCdwGBgN+CfImIg8NfMnLyOZh3NK8O79wM/aj9ovz8iPgI8DgwARmbmxWWR3SLiVIop4Vdk5sMRsS/FqMulwMrMvDIijgXOo5jqvQfwNoqRh5cBP6QYgbhzZn6lfN4/A09TTBH/ZvmbHASMiYijKEZ+/nUd77ZGRBybmdd01obMfH9EfBq4F9gOWJCZf4iIb1GM2nwIOAL4TDnS9DBgB4qgeERmXtLhcbcBbwEe7krb6sExxxzPueeewx133M748fux7bajmDnzBe6883YeffQhFi1axFlnnQ3Q6TlJkiRJkqRNWd2FjRHRC7gASGA88GngPyLiceAtEfHhzFxQc8tLwJE1x6siYlLHejPz6ogYnZk/jIgTKaZS70OxbuBfutC0PsCKDud2BOZ0Uvb5zLwuInYAvga0h42tmfmzcu3H/wQ+CHw8M08r3/3HEfHLMuw7FRiUmT+PiMnlupOzgSszsyUiLi3vOR6YmZm/j4hngQ9l5teB6yPifZl5fRferW9ETKRY03IAcE1nbSj/bRK4EdgV+DzFFOy7gIWZ+duIGE4xPf3PwD9m5nvK6e2nd/LcFcDALrRvk9bUNJgBA/rR1DSYxx57jEmTjmfAgAFcdtllvPvdJ9PQsBMf+MB7GT16NN/4xjdoaVnEHnu88twOO+zQ06+ibtbUNLinmyCtl/1U9cB+qnphX1U9sJ+qHthPNy11FzZmZltEzMjMiyPirDJYuyczL4uI3h2CRoA2YKfyE4pRf9sDvTqpvi0i9gOuA95DsX7ibhFxZxc2irkL2Iti9F67ucDwTsoOjYjTKEYArqw5/0z5jovLUA5gpzLog2KE3yCKkYlk5rTyc2l5fVlmtrS/S/n5emBxWUd/ig1yNlRrZk4BpkTE62ovdGxDRIwB3l2+W+00/YXl5wpgK6AJWFTe2wp8v5Pn7s9Gnl7eHebMaWb58pXMmdPMlVf+mjPPPIu+ffsyffoMrr76et7whvFryg0aNIwnnpjBihW9X3Guf/+hPfgW6m5NTYOZM6e5p5shrZP9VPXAfqp6YV9VPbCfqh7YT3tG7969aGzsfGm4el2zsT1I61d+9i7XIOzfSdnemfmyICszLwJeNt06Ig4FRgMzgXcAv6QIJP8IvLcLbboUeFeHc3+imAbc/ozjylGLR2bmJZl5P7C63Il6zfuUQeML5bmZmTmlDPt+mpkb+l/Q48Ccso4/ATfVXFtVPm9MVyvLzEfWdq1cX3FkZl6emY+W5/qtpfhcik1z2u/dr0NdQ4B9u3Mjmp7Q0PC3/xCbmkbSv39//vjHydx//z0AzJ07h9GjR3d6TpIkSZIkaVNXr2HjmyPi48CKcuru4cCpwKPllNxaAyJiNH8bydg7Il42RKxcA3JgZp4H7AJMKUdIto+UbIqIj3e8r1ZmLgd+EBGnlW0CuBxoKO89jSLIfAlYGhF/FxEnUYwunUgx4nKbcor3B4GvlnV8OyI+FRHvoZjWTUQcAuwSEZMiYmR5blTxEbtGxLbAnhGxG/A7YK+I+EBEvJ+Xj6T8c0R8imJDnE5FxE7AzhHxhg7nX9EGYEb5W51U824HUEx3H1+WGQ/sV44UvSIiPlO+28iauocAHwA+s7Z21ZNp06Zwzz13cccdtzNp0glcc81VTJ06hRdfnMX++7+Jo446hvnz5zNlyg2MGDGC4cNHdHpOkiRJkiRpU9erra1t/aU2MRExuHaEX0QMy8yFayl7NvBjio1RzgQ+RDHV+Z8z85QOZfsCQ9s3jimnaV+0gW3rBwx4FSMQVYqIbcrdqKswBph+5vnXMnvBsoqq7LrJF57gcG51iUP/VQ/sp6oH9lPVC/uq6oH9VPXAftozaqZR70KxKfEadbdmI0DHIG9tQWN57dsAEfHBzFwVEReV6z4+20nZVopdk9t971W0bSUvHz2oDVRh0ChJkiRJkqSNqF6nUW+wMkgkM9vKz1eEjZ3cU3/DPiVJkiRJkqQessWEjZIkSZIkSZK6l2GjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqRN+eboC0MVx87tE98tzlLa098lxJkiRJkqSeYNioLcK8eUtYvbqtp5shSZIkSZK0WXMatSRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqkTfrhSKiG8APwYWABcCV2bm5d3ZMEmSJEmSJEn1pasjG1/MzLuAzwCnAwu7rUWSJEmSJEmS6lJXw8Y7ImIA0CczF9DFEZGSJEmSJEmSthxdDRv3Ai4DLo6IYcBHuq1FkiRJkiRJkupSl8LGzPwmcFpm3g7sCPx7t7ZKkiRJkiRJUt3p8nTozFxSfj7Yfc2RJEmSJEmSVK+6uhv1QcC/APcDPwC2L0c5SpIkSZIkSRLQ9TUb35SZJwI3ZuYMYKfua5IkSZIkSZKketTVadQzys+28rOhG9oidZvGxu7psstbWmlevKxb6pYkSZIkSao3XQ0bt42IDwMNERHAsO5rklS9M8+/ltkLqg8FJ194As2V1ypJkiRJklSfurob9XeBJ8vyL2Tm17q1VZIkSZIkSZLqTlc3iBmdmTcAN3RzeyRJkiRJkiTVqa5uEHNRRAzq1pZIkiRJkiRJqmtdDRsvy8yX2g8iYo9uao8kSZIkSZKkOtXVDWJejIgzgOvL4wnA493TJEmSJEmSJEn1qKsjGz8D7AicXv4d3W0t0iYlIho3oOzQiBjQxbK9Xn2rJEmSJEmStCnqatj4P5n5xfY/4H+6s1HapHx+fQUi4svl1zHASRHREBGj1lL2o+XXYyPiDZ1cH7iO52wXEYduikHlDTdcC8DixYuZPPm3XHPNH7j66slrrl9//Z+44YZrufDC//ey+6ZPf4pLLvnBRm2rJEmSJElSd+nSNOrMvLbDqRnd0BZtYiJiHPDrtVw7FtimPBwTEe8BxgGPUIx8nVX+tZfvBQwDGiPiMODtwN0RcTAwLzN/URbdNiI+A1wAnARsDTQD44FrKPpef2B5ZS/6Gt1yy1SuvvoqjjzyaO6//x4aGho44oij+PKX/y/HH/92Zs9+kSVLlnDiie9kxYoVtLW10atXkZdOmzaFVatW9Wj7JUmSJEmSqtKlsDEifg0sBHoBQ4BW4O+7r1nqSRExCfgDcADwQHm8DbAPcGlmPpCZ15RlvwJcATwMtAErgL2Bu2rq2xc4GOgHbE8RGN6WmZdFxMDMXNZeNjOfjoivUwSMVwJ7Ac+V9T4E7J6Zm0zQCHDooYdx8803AjBhwkTa2toA6Nu3HwBTp97E2LH7AHDccZPW3Jf5V/ba63U8+OD9G7nFkiRJkiRJ3aOrG8R8NjMTICL6Ae/pviZpEzAM+ATwNEVA+DhwK8WIwr+2F4qIscB0ihGNo4Any8/nyz8AMvPeiHgA+A1wFXAsMKicUn1kRJyWmYsiogE4CLgRaAS+CswG5gO7A/OA0d310lVZtmwpF130bSZOfAsAM2fOZOXKVu6//15mzZrFxz/+KXr16sWMGc8wduw+ho2SJEmSJGmz0dVp1FnzfWVEDOu2FmlTsBD4c2Y+WXsyIrbKzBXl94HA4cBiYBmwGzCcYvThqMzsODf4/cAPKYLMP1OMcLwJWJ2ZiwAyc0lELAZOAJYCU4GVwI+BD5Tlj6v4XV+zpqbBDBjQj6amweWZwXzlK+dx3nnncdBB+9PWtpI3vGFvJk6cyC9+8QueffYxevXqxVveMoGVK1cyaFD/mnu1JbMfqB7YT1UP7KeqF/ZV1QP7qeqB/XTT0tVp1F+gmCILsBVFqKTN11LgnyLiWYqwrx/wF8oNhcr1F48FfgX8G/BUec9y4FmK0Y1rRMThwC3AMWUdxwDTgB34W78CIDP/EhHbAO2bx7RkZltEjASOAF6q+mVfqzlzmlm+fCVz5jSzePFi+vTpzaBBDYwatSPXXz+V/v0H0b//EObMaWbQoGE88cQz9Ou3FXPnLmb+/Hk8+eTT3HvvI+yww449/SrqQU1Ng5kzp7mnmyGtk/1U9cB+qnphX1U9sJ+qHthPe0bv3r1obGzo9FpXp1E/ShE2ASzPzBeraJg2WUuBn2XmXbUny81cyMw2iinRRATAUGA7/rZmY8d+9SDwXooRkMOAJopRkTfTIWwsHU+xXuNhwDcioi/wR6AF2Om1vlx3uuaaPzBixAiOOuoY5s+fx157vY6tt96av/71EXbffQ/mzZvHbrvtzh57BAAzZ77AM888bdAoSZIkSZI2C727Uigzr8zMZ8o/g8bN31JgQO2JcjTjgE7KzgSeoViL8RGKzYN61RbIzPmZ+U2KoPGXwHXA4JryHW1XbgLzHLAH8E6K0bTbsAmObJw2bQr33HMXd9xxO0cddTQLFy7gxhuvZ/DgIey1194ccMCbmT37RaZMuYHW1tY1QWNLy3KmTZvCww8/xKxZs9bxBEmSJEmSpPrQ1WnUe2bmY+X3XYD9M/OX3doy9bT/FxHLgAaKqfO9gT/VFoiIwcAsYAowEPiHstzaQuzewKHl55Ly+wMd6ns/xehIKKZSN5dtGEsROE5+zW9WsQkTJjJhwsQ1xyeffOrLrvfu3ZszzvjwK+7r338Ap5zyHk45xf2WJEmSJEnS5qGr06hHAY8BZOb0iHhb9zVJm4AlFDtB35iZaxY+iIg31hbKzOaIuDQz20cn/mu5Q3X/zirNzK/W1NUb+ArwuQ71XQ40REQf4GHgqsx8qbxnD4oNaSRJkiRJkrQJWmfYGBF7Ah8HdomI08rTrRRrOGozlZlPUWz60vH8XZ2ca+1w/HAXn7Ea+NdOzi8AFpSHF3W49nhX6pYkSZIkSVLPWGfYmJmPRcQXgb0z8+aN1CZJkiRJkiRJdWi9G8Rk5mxq1tWTJEmSJEmSpM50dTfq9mmtRESfiDi++5okSZIkSZIkqR51dTfq04GjgJVAG9AHuLob2yVJkiRJkiSpznR1N+r5FJt5DM7MRyLipG5skyRJkiRJkqQ61NWw8aXMnBERJwOPAKu6sU1S5S4+9+huqXd5S+v6C0mSJEmSJG0huho2vjEiACIiTgQmAL/vrkZJVZs3bwmrV7f1dDMkSZIkSZI2a10NG/8LGAhMBc4ALumuBkmSJEmSJEmqT13djbqFYlOY7YDvZ+aD3doqSZIkSZIkSXWnS2FjRHwA+CpwEjAyIt7Rra2SJEmSJEmSVHe6FDYCqzLzTODezJxJMaVakiRJkiRJktboatjYq/xs32Fjm25oiyRJkiRJkqQ61tUNYuZGxPeBARFxGnB19zVJkiRJkiRJUj1aa9gYEacAwzLze5n5x4i4DdgDeCoz52+0FkqSJEmSJEmqC+sa2XhyZp4CEBEnAmOB3xk0SpIkSZIkSerMutZs/FH7l8z8LfBkZj7U7S2SJEmSJEmSVJfWFTau6HD8QvuXiNile5ojSZIkSZIkqV6taxr1dyLiufJ7L2BYRCwov28LvK67GydJkiRJkiSpfqwrbHx/Zt7e2YWIOKSb2iNJkiRJkiSpTq11GvXagsby2q3d0xxJkiRJkiRJ9WpdazZKkiRJkiRJUpcZNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEr07ekGSBtDY2NDpfUtb2mlefGySuuUJEmSJEmqd4aN2iKcef61zF5QXTg4+cITaK6sNkmSJEmSpM2D06glSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwcQsWEZX/+0fE0IgY0MWyvap+viRJkiRJknqOYeMWJCJ2iog3ld/fCOwSEaevpewHN7DuL5dfxwAnRURDRIxaS9mPll+PjYg3dHJ94Dqes11EHLqpBJU33HAtAKtWreKqq37HzTffxCWX/ACAJUuW8Jvf/JKpU6fw+9//ptP7JEmSJEmSNid9e7oB2qiWATsAdwIjgBVAH4CIaMjMJeX3A4GZ66ssIo4FtikPx0TEe4BxwCPA0cCs8q+9fC9gGNAYEYcBbwfujoiDgXmZ+Yuy6LYR8RngAuAkYGugGRgPXAPMAPoDy1/Nj1CVW26ZytVXX8WRRx7NHXfczuDBgzn88COYOfN5nnrqCe655y6OPXYSDQ0NTJlyA0899QS77rr7y+6TJEmSJEnanBg2blnaKIK8/SiCxhUAETERaALaw76DM/O/IuJoYCCwa3lvC/BCZv4OIDOvKe//CnAF8HBZbgWwN3BX+4MjYl/gYKAfsD1FYHhbZl4WEQMzc1l72cx8OiK+ThEwXgnsBTxX1vsQsHtm9mjQCHDooYdx8803ArDtttvywgvPr7m21Vb92XrrQdx++60cddQxLFq0iEGDGl5xnyRJkiRJ0ubEsHELERHvpxht+BwwHTgG+B6wL/BM+6jCiHg38HhEnAwMzcyLI6If8LHM/E4n9Y4t6xsHjAKeLD+fL/8AyMx7I+IB4DfAVcCxwKBySvWREXFaZi6KiAbgIOBGoBH4KjAbmA/sDswDRlf641Rg1113Z9dddwfghReeZ/vtd2C77UZz7rnncMcdtzN+/H5su22ns8olSZIkSZI2G4aNW4jM/HG5TuNQoBX4c3np8cy8rqZoX2ApMC4z29dhbAWWdKyzXFvxcGAxxRTt3YDhFKMPR2Xmqg63vB/4IcVU6j9TjHC8CVidmYvKdi6JiMXACWU7pgIrgR8DHyjLH/fqfoVqNTUNZsCAfjQ1DV5z7uqrr+YjHzmLkSOH8NhjjzFp0vEMGDCAyy67jHe/+2S22morgFfcJwH2CdUF+6nqgf1U9cK+qnpgP1U9sJ9uWgwbtxARsSfFWo0LKKZDTwRuBXaNiI8BP8jMZZn5k4g4C7iwZh3HPsCqDvX1ohid+Cvg34CnKMLB5cCzFKMba8sfDtxCMaKyd/k5jWINybbaspn5l4jYBmjfPKYlM9siYiRwBPDSa/9FXrs5c5pZvnwlc+Y0A/DIIw8xYMAQBgwYxpw5zVx55a8588yz6Nu3L9Onz+Dqq6/nkEMmALzsPgmK/znaJ7Sps5+qHthPVS/sq6oH9lPVA/tpz+jduxeNjQ2dX9vIbVHP2Z9iavIgivUUH6TYBOYBik1X9gGIiE8AewBvA3Yu7+0DrK6tLDPbMvM3mflieWoosGP5uYJXBtkPUoSTy4GtKEY1Hk6xwUwbr3Q8cBtFGHltRPQF/kgxanKTCBtrLVu2jOeee4599hlHS8ty7r//Phoa/vYfXVPTSPr379+DLZQkSZIkSep+ho1bgIhoolgrsQ+wKDO/D7RlZhtAZj5OsRYiwDcz89OZ+avy3gEU/aTjlOhaM4FnKNZifIRi2nWv2gKZOT8zv0kxhfqXwHXA4JryHW1XbgLzHEX4+U6KKdrbsImEjdOmTeGee+7ijjtu5w9/+B1Tp97EF77wWT760Q8zZMgQJk06gWuuuYqpU6fw4ouz2H//N73iPkmSJEmSpM2J06i3AJk5ByAitgZWRcQRwJ/Ky8PLz/ER8SywY7k79UsUazG+niLgG1fe3wD8ODNnl3UOBmYBUyh2rv4HinBybUF2b+DQ8nNJ+f2B9otlfe+n3CmbYip1c/ncsWV7J7+6X6JaEyZMZMKEiQAccMCbOfnkU19RZtKkE9d5nyRJkiRJ0ubEsHHLMpdiqnNLZj5dntshIqZQjFy8i2In6Csyc1m5M/TWwNzMXN1JfWRmc0RcmpntoxP/tdyhutM5w5n51fbvEdEb+ArwuQ71XQ40REQf4GHgqsx8qbxnD4oQVJIkSZIkSZuYXm1tnS2Xp81VRPTLzJU93Y6NaAww/czzr2X2gmWVVTr5whNcgFaVclFj1QP7qeqB/VT1wr6qemA/VT2wn/aMmg1idgGeftm1nmiQes4WFjRKkiRJkiRpIzJslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlejb0w2QNoaLzz260vqWt7RWWp8kSZIkSdLmwLBRW4R585awenVbTzdDkiRJkiRps+Y0akmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVMGyUJEmSJEmSVIm+Pd0AaWNobGx4Tfcvb2mlefGyilojSZIkSZK0eTJs1BbhzPOvZfaCVx8WTr7wBJorbI8kSZIkSdLmyGnUkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkirRrWFjRAzucNyrC/est4wkSZIkSZKkTU93j2zcKSJOrjneJyIOWc89x0Vht648ICL6RsQ/RcQGvUtE9IqI/htyjzaOiGjcVEPnG264ds33iy++iCuvvII//elqAFatWsVVV/2Om2++iUsu+QEATzzxOKef/h6+8IXP8slPfoybb76xR9otSZIkSZK0MXR32PgSsBAgIgZk5gPAqPJ46DratAhoi4gPdrwYEUMi4o0RcUZENALnACszc3VXGxURQ4D3AKs25GXKe/tFxMgNvW9LVv6bHb0BtzQDH4yIhu5q06txyy1TufrqqwDI/Cv9+/fnlFPezb333s3KlSu5447bGTx4MIcffgQDBgzgqaeeYPHiRXznOz/ki1/8D4499m0ceujhPfwWkiRJkiRJ3afbwsbaoCgiBgLvLMPD4eXnRWu5dTgwOzOfAn4aEXt3CJ3eCLwL+DmwFdAXGBcRZ0fE+7rQrt7AJ4GfZWZrzfnTI+LdEfHRiPjTOqr4Z+D49T2nShERXSx3YEScExEfjoifV9yGMyLi66/y9g8Bo9dS7yveLTNXAD8BPvcqn9ctDj30MEaMGAHA7bffyj77jAdg++135JFHHmbbbbelT58+a8pvtVV/9tvvjQwYMIAVK1awevWql12XJEmSJEna3PTtxro/AgwFGoH3AfcAP8zMJRGxN3B1e8GI2B04jmIk5CHAjhExC1gNzAOWlH9k5o0RsUtmvhQRE4ArgBOB72ZmV0YqnghMrS1b1rN7Zn6+PH4mIvqspb67gTFd/hVeo4gYRBGOnrWecr2BszPz/eXxQxU35ffAlFd5b6e/2breLTOXR8R9EXFcZv7xVT6328ydO5fhw4cBMGTIEObNm8u4cePZddfdAXjhhefZfvsd1pS/8cbreNObDuyJpkqSJEmSJG003Rk2zgOuBHYHxgI/AP4tIj4PLM7MF9oLZuYTwDcBImIrYBbwEPACsGtmzmgvGxHHA2+NiDbgTmAwsBvwT+UIyr9m5uR1tOtoioCr1vuBH9W0Z3L5rI8AjwMDgJGZeXFZZLeIOBV4PXBFZj4cEftSjLpcSjGt+8qIOBY4jyJM2wN4G/BZ4DLghxRh6s6Z+ZXyef8MPA28ofw9moGDgDERcRTwXGb+dS3v9WYga97htprfrGO9g4H3AkOAB4CjgO8CRwC7ADcDBwMXZuaMMgx+NzADeKqssxdwJvA8cDLw0zIIHlu2+Vlg78z8n/b2lYHoIcCXyrrW9263AJ8CNomwsalpMAMG9KOpaTADB/Zj+PBBNDUNpqGhP0OHDqSpqdgP6eqrr+YjHzmLkSOHrLn32Wef5B/+4dSearrqRHsfkjZl9lPVA/up6oV9VfXAfqp6YD/dtHRn2DgM+AJwAHBVZi6NiBeBQcD/RsTfZ+by2hsioh/QBvSiCNo+CfyqtkxmXh0RozPzhxFxIkVgtg/wo8z8Sxfa1QdY0eHcjsCcTso+n5nXRcQOwNeA9rCxNTN/Vq79+J/AB4GPZ+Zp5Xv8OCJ+mZnXlKHkoMz8eURMLn+H2cCVmdkSEZeW9xwPzMzM30fEs8CHMvPrwPUR8b7MvH4977UjMLusaw/gE8D3ge06q7ecZn0Rxb/Rb4GVFCFkaxmULgQmAJdn5hMRMY2Xj04cDIwHLgX+BOxanv888L7MXN1hk5+Hy3+zZ4FDM/OnXXi3FcDA9bz3RjNnTjPLl69kzpxmBg0ayvTpzzN4cBMvvDCbpqbtmTOnmUceeYgBA4YwYMAw5sxpBqClpYXnn5+15ljqTFPTYPuINnn2U9UD+6nqhX1V9cB+qnpgP+0ZvXv3orGx8602unODmKeAb1OMTPtueW4oxSi493cMGksnUARfAynW+ftWZj7aSbm2iNgPuA7oD1xCMdqwK+9zF7BXh3NzKdaK7GhoRJxGMRV8Zc35ZwAyc3HNfTtFxMSImAg8TBGqUpabVn4uLU8ty8yW9ncpP18PNJb3bwu82IV36fgOjeVzHgd2yMx711PvnzOzNTNbajbYWVh+rqBYE7NT5btfCXwP+CLwXHlpQHtdmfmdmlva/8tvBfp18Z32p5iCvck58MCDeeihBwB47rkZvO51r2fZsmU899xz7LPPOFpalnP//fcB8Oyzz7DVVmv9KSVJkiRJkjYb3Rk2/pZi9NtBwPvK6bWLMvNHmbkoIt5SW7icPj2YYiry0cDXM3NheW3/mnKHUmw2MhN4B/BLipGQf6SYGrw+l1JsMFPrT8Ca9kTEceWoxSMz85LMvB9YXY68hDIsi4jhFFO9oRg9OCUzp1BMKd7QWP1xYE5Zx5+Am2qurSqfN2Yd998C7Fdz3B5irqveV63897wnM0+nGH16RofnEoVBnd1fo9N3i4i+FMH0T6pobxWmTZvCPffcxR133M5ee+1NS0sLV155Ofvuuz99+/blD3/4HVOn3sQXvvBZPvrRDzNkSDGNuk+f3mu+S5IkSZIkbc66ZRp1RAymWJvwWopRb/0pRsrV7uK8S4fbTgb+ALQAIzu0bQ/g7nLk4sDMPC8iDgamZOaCiOhdfjZFxMeBSzJzUWdtKzce+UE5YvHSzGwDLge+WN67CLiPYrOapRHxdxQBWl9gYtm+bSJiErA38NWy6m9HxKcoQtAFwHMRcQiwS1n2jsycHRGjip8odi2fsWc53fh3wGcj4gPl82p3xP5zWfcTFGsvdvZeLRFxWUScQ7Ee4l3lpVfUGxHbAUcCr4uIN2fm7WXZ8fxtqvR4iqnRl5RrNh4CjIqIuzPzQYqRm5dFxA8o1rS8ubzvvyLi3yhGti7PzIyITutd27uVwfMZwL+XO1NvEiZMmMiECRPXHJ9++odedv3kk0/l5JNfuS7jrrvuzsc+1nGZUEmSJEmSpM1Pr7a2tvWXqkhEfJpiN+jVFFOljyh3pz4SeDAz29cc3I9iPcGXKAKyuZn5rpp6+gJDM3NeeXxWZl60gW3pRzHl14n9m5iIGAEsKIPg12oMMP3M869l9oJlr7qSyRee4BoQ6lauM6J6YD9VPbCfql7YV1UP7KeqB/bTnlGzZuMudBgY150bxLxCueHJ1zu5dEdt6JeZ9wBvWkc9rRS7Xbf73qtoy0pevg6jNhGZOb+n2yBJkiRJkqQN151rNnbZax1dWNEIOEmSJEmSJEmvwSYRNkqSJEmSJEmqf4aNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiqxUXejlnrKxece/ZruX97SWlFLJEmSJEmSNl+GjdoizJu3hNWr3bRckiRJkiSpOzmNWpIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVaJvTzdA2hgaGxs2+J7lLa00L17WDa2RJEmSJEnaPBk2aotw5vnXMnvBhgWHky88geZuao8kSZIkSdLmyGnUkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkirhbtTdLCKGACsyc3lPt0UbbsmSJVx33TU0Nm7DwoULeN3rXs+Xv/wFdtppZ5qbl3DCCSex775v5Oabb6Rfv36sXr2a449/e083W5IkSZIkqUc4snEDRMTYiOhffn/rOspFROxbHh4CvGkt5Q6PiDE1x70iYlj5fWAX29SrvU2bi4joHREjerodANdccxVvfeuxHHbYRIYMGcJ9993Nd77zQ774xf/g2GPfxqGHHs79999DQ0MDxx77Nu699+6ebrIkSZIkSVKPMWzcMH8PjC6/7722QpmZwFHl4QDgjojYoZOiuwLNEXF0RHwE+CFwekR8DPjW+hpTjpp8D7Cq66+w6cvM1cD4iDigp9uy9daDuP32WwFYtGgREyZMZMCAAaxYsYLVq1fRp08fJkyYyMSJRwLQt2+/nmyuJEmSJElSj3IadRdFxM7A7MycXp5aHRETgOWZeWdZpi/wQYoQd2FE/CfwOHAK8FxEvFAGae0agO2Bu4F9gFsogsPrgCfW057ewCeB8zJzVc3504HlQCPw9sw85rW9ec/IzBsj4iMRMT8z1/lbdKdjjjmec889hzvuuJ3x4/dj221HAXDjjdfxpjcduKbcsmVLueiibzNx4lt6qqmSJEmSJEk9zpGNXRARfYDTgGciYkJEnAXsASwAsr1cZrZSjE6cAbQCIyjCw/7Are1BY0RsHRFnAq8H/pliFORYYOeyqjcB166nWScCUzsEjROA3TPzisz8FvCtsu316ofAp3qyAc88M53DDjuCgw46hKuvnszKlSsByPwrjY3brCm39daD+MQnzuG226axYMH8nmquJEmSJElSj3JkY9f8HfBTikDwOaANGA8cCBweEXdl5l/KsiuBp4CZwL7AaqAX8KGIuDUz78vMpRHxE4oRiA2Z+fOIaKAIKHsBj5Z137aONh1NMbKx1vuBH7UfZOZkgHKK9uMUU7pHZubFEXEscB7QHpy+DfgJ8BGKAHUhRfj5JWA+cDbFaMs3ABdQTAH/X+BSYCDQlpnfL9eP7Fh2N+BDwLPAbOCdFCHrK+otA9v29i+PiOHr+A263a233sTHPvYx+vXrR0vLEjLv5+CDD2bp0sU0NQ0GiunVffr0oaGhgTe8YSxPPvkIxx13XE82W3WqvU9JmzL7qeqB/VT1wr6qemA/VT2wn25aDBvXIyKGApOBbSlGKe5OEY49kZkXdyh7GDAOeAF4niJ4bC8zPDNrh7ztQzF9+q3lSMnXl/fMAp4EjmXdYWMfYEWHczsCczop+3xmXleuG/k14OLMvCYiTgUGlWHnZGAk8BBwA0WYOAvYkyJknZaZd5bTt0/MzF9GRDNwWWa2RcSlwPeBM9dS9irgHzLzzIj4fRm4fqRjWeCXHdreax2/Qbfr3Xsr5s5dQt++fRk4cAjLl6/m7rsfYvXqXsyZ0wzAlVf+nBEjRnDUUcfwzDPPc/DBu665JnVVU9Ng+402efZT1QP7qeqFfVX1wH6qemA/7Rm9e/eisbGh82sbuS11JzMXZeZyoB/FSMSbys/GiDglImoX6bsTWEoRTL6FYt3EfwVOBw4q13Rs9wRwJEVAOA/4KkVICXAExdTrdbkL2KvDublAZyMBh0bEaWV7VnZ4v2nl59LyVPu07Pa1JXtRBKHbR8REipDzpfLaosxsK7+3f66tLEDHZ62rbPsamD26+c2kSSdwzTVXMXXqFF58cRb77/8m+vTpzZAhQ9aUOeqoo1m4cAE33ng9gwcPYa+91rp3kCRJkiRJ0mbNkY1d1x58jaMIE5cBf8zMNfF5Zi6LiCszszki/o1i6vBHgN9n5tzayjJzUUS0UkxdPgr4NX8bxbeEYhr2ulwKfJZiJGK7P1GEnHcARMRxwK3AkZn5gfLc6ojol5kr6brHgRmZeXe5BuTIjVT2TOCiDWhn5YYOHcakSSe+7Nyuu+7Oxz72txnsI0Y0cvLJp27klkmSJEmSJG16DBu7blD5NxNopthF+l3l9N82iunELWXQeBrw68xcGREXAz+JiC8D99RsEnMM8BuK0YmTKULJl8q67szMP6+rMeV6hj8on3VpOcLwcuCLEfFxYBFwX1nn0oj4u7LuvsDEiFgK7BIRk4A7MnM2xdqKuwDPAGPKR/UBvgd8OiL2Lu+/MiJ2LV4jti1/l4iI7dZR9hBgVETcm5n3l3W/omz7+5WjHZ/OzJvX8+8iSZIkSZKkTUSvtra29ZcSZSA2kmKTlWeBFzJzUYcyuwP7UewSPavm/OuAm4GngQ8C04F+mTkvInbNzKciYlBZ/9HAD2p3mV5Pu/oBA2pHWNa7MsAd1mGNy1drDDD9zPOvZfaCZRt04+QLT3DdB200rjOiemA/VT2wn6pe2FdVD+ynqgf2055Rs2bjLhR51xqObOyizHyUYpfoTpXTgJsz88qO1zLzEaBpLfU+VX6+BEyPiC4HjeV9K+mwDmO9K0d/VhE0SpIkSZIkaSMybKxIGRC+WFE9kiRJkiRJUt1xN2pJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJN4jRFuHic4/e4HuWt7R2Q0skSZIkSZI2X4aN2iLMm7eE1avberoZkiRJkiRJmzWnUUuSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEr07ekGSBtDY2PDBpVf3tJK8+Jl3dQaSZIkSZKkzZNho7YIZ55/LbMXdD08nHzhCTR3Y3skSZIkSZI2R06jliRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJd6OW1mLJkiVcd901NDZuw8KFC3jHO07i4osvYvDgIQwdOpRjjjmexYsXc9VVv2X77XektXUlRx55dE83W5IkSZIkqccYNnYQETsBRwGtwCCgGegPPAz8JTPbOrnnHOBrnV2rsF29gK0ys6W7nrGpiIhtMnNuT7fjmmuu4thjJ9HQ0MCUKTdw33330L9/f0455d1ccMF5vOUtb+X3v/81Rx11DKNGbcell15Mc3MzgwcP7ummS5IkSZIk9QjDxhoRcTjwaWAI0AdoAX4NtAEHAm8D/q3DPUeX1ydExP7A1My8u+b6d4CTgdUUweUs4EVgLrAQWAz8V2YuXUe7hgBvB36+nva/KzN/0fU3Xmdd/YDhmTm7ivo20MqI+BDwo8xs7YHnA7D11oO4/fZbOeqoY1i0aBFPPfUk++9/AADbb78jjzzyMDNnvkBj4zYAjBjRyCOPPMSBBx7UU02WJEmSJEnqUYaNL7cf8CVgNEUo+HrgAWB3YD4wpbZwROwHHArcTLH+5bbAfR3q/ALw38BzmflSRPQFVmfm6ogYmpmL1tWgiOgNfBI4LzNX1Zw/HVgONFIEke8GPgpUEjYC5wDPA5dUVF+XZeaiiPgN8C/Alzf289sdc8zxnHvuOdxxx+2MH78fCxYsYPjwYQAMGTKEefPmssMOO/H448nee4/l4YcfZMCAAT3VXEmSJEmSpB7nBjEv9z/AMmArYCTF6MMJwHuBYbVTmCNiL4rRindQ/I4HAJ+rDQQBypGBpwAnR8RFwB7AdyPiE8CPIqJxPW06kWK0ZG3QOAHYPTOvyMxvAd8CFgHTX+2Ld+LWCuvaYOU06paIGNtTbXjmmekcdtgRHHTQIVx99WTa2lavudbW1kavXnDiie/kvvvu4eqrJzNq1HY0NDiFWpIkSZIkbbkc2fhyvYF3AfcDE4Efluf+ACzpUPbxzFwVEWMoRjdeVY5W3Ckzn+1Qthn4KdAvMx+NiHsz8zsR0ZyZ89bTpqMpRjbWej/wo/aDzJwMEBFExAco1prcPTM/GRG7Ukz/fhB4C/B1imni7y0/H6BYo/K7wD3AucDTQABPlPUeAoyhGN25TWb+JCI+DexCMarzYOBCivD1svJ3Ww3snJlfiYg3UYwSnQ68Ffh3ihGZvwM+TBHwXgB8pMO07dvKNj+8nt+oW9x660187GMfo1+/frS0LGHRokXACpqaBrN6dQu77bYTO+00ko9//GwAvva1rzFu3N40NRk46tWx76ge2E9VD+ynqhf2VdUD+6nqgf1002LYWCMzWyNiNEUo9hhFYNa3/Oy4Yck+EbEbRTB3BHBURBxYfp6Umctryr4EHFlzvCoiJnWxWX2AFR3O7QjMWUv5X2dmc0RcUh4PAq6imBZ+CDA+M6dGxM+Biyimef8WWAm8A3gqM38aEROBMeXGNB/KzNMAIuJzEbEncBfQmplXRsRCYEJmXh4Rs4ErM7MlIi4t29CfIlhcCZwKbJ+Zz0bE/wBNFL/hf3eyPuQKYGAXf6fK9e69FXPnLqFv374MHDiEBQuWcMstt7PTTnuS+QTveMcp3Hffo8yY8SxvfvPBzJ27kK23HsGcOc091WTVsaamwfYdbfLsp6oH9lPVC/uq6oH9VPXAftozevfuRWNjQ+fXNnJb6sF8imnUyyg2djkAOKY8BiAitqIIJB+hCBGvpVjrcQTwvg5BIxQbyOxUc7wa2J6uhb13AXt1ODcXGN5Z4czs+F/Yi8A/AIdTrPFY+2/+58xszcyWzFxdPuexDvdvQ827A08C48rvC8vPFRS/GcCymunm7btzzwb+EXgjsLSmDb+nGOl4AMUoxo72B+7u5PxGMWnSCVxzzVVMnTqFF1+cxamnvpeWlhauvPJy9t13f/r27Uu/fv2YOvUmfvGLn3H88V3NjyVJkiRJkjZPjmx8pW2BGeX3/wT+HrglMx9oL5CZKyLiIGBFZn41Ij5IMf34u2uZFt07M79Xlmuv46La43W4FPgs8FDNuT9RTC++AyAijivPdeYzZbuejIhRQK+I6LOWsk8D25Xf29eSnAv0qykzhmIk5HZ03ZeAD5SjHQ+n7HeZubTcAIcy7Fyj3IF738y8aAOeU6mhQ4cxadKJLzt3+ukfetnxyJHbcs45n9+IrZIkSZIkSdp0ObKxRkQMBG4oN125FDiBchRhOXV4jcy8OTP/HBFvoZjq+9XMnPGKSgsDyunZvcrj3hExtCttKkdJ/iAiTiunNANcDjRExMcj4jRgJtAA7BIR48ugbpdyt+wbgXdHxInAKOA4is1vjgReFxFvrnncr4EDIuJdwJ7AruX5H0fE30fE8cDTmZnA+PKP8nO/MsyMiNg1IrYF9iynml8LfLhswyCKqdTtbqHY3GaNsv0foAhKJUmSJEmSVCcc2fhyK4F7ImIkxQYpv2qfEhwRZ0fE7sB1wGBgLMV6g3dn5o3rqXcVxSYxh0RE+6Yz+1Bs/vKD9TUqM2dExE8pAsXmcmfqczspevhavv+xk7IXl3+1z1m5lnqndtKm/+7sO3BQzfeDy88na879tkNVvYAbOpzbKjO/2Uk7JEmSJEmStAkzbKyRma38befj2R2ufbv9e0S0ZOa0Daj32+V9Hyx3sL4oM9siouOu1euqYyVFGLrZiIhfAr/IzJdtgJOZHTfjkSRJkiRJUh0wbHwVMvOlV3lfa/nZVn52OWzcHGXmyT3dBkmSJEmSJFXHNRslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIl3CBGW4SLzz16g8ovb2ntppZIkiRJkiRtvgwbtUWYN28Jq1e39XQzJEmSJEmSNmtOo5YkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZXo29MNkDaGxsaGtV5b3tJK8+JlG7E1kiRJkiRJmyfDRm0Rzjz/WmYv6DxQnHzhCTRv5PZIkiRJkiRtjpxGLUmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkS7katSkXEUKAlM5d3oWyvzGzbCM1ar5kzX+CCC85n2LChAJxzzucZNKiBG264liOPPHqdZSRJkiRJklQwbNRaRcQHM/MHXSz75cz8PDAGeF1ETAYaMnNWJ2U/mpnfAo6NiOcz84EO1wdm5rK1PGc7YDfg1qqDyjPO+DDjxo1fc3zLLVO5+uqr1oSNnZWRJEmSJEnS3xg2qlMRcSAwcz1ljgW2KQ/HRMR7gHHAI8DRwKzyr718L2AY0BgRhwFvB+6OiIOBeZn5i7LothHxGeAC4CRga6AZGA9cA8wA+gPrHT35Whx66GHcfPON3fkISZIkSZKkzYpho9bm4Mz8r4g4GhgI7Aq0AS3AC5n5u8y8BiAivgJcATxcllkB7A3c1V5ZROwLHAz0A7anCAxvy8zLOo5kzMynI+LrFAHjlcBewHNlvQ8Bu3dlmvaGuvPO23n00YdYtGgRZ5119qsuI0mSJEmStKVygxi9QkS8G3g8Ik4GdszM3wHfAnpn5nfK4/ayY4HpFCMaj6QYybgV8Hz5B0Bm3gt8F3gLRQh5LDAqIj4KXF6u9UhENETEW4Fny3q+CkwCTgEOAsYCu1T9zsOHj2DSpBM59dT30bdvX2bOfOFVlZEkSZIkSdqSObJRnekLLAXGZeaXy3OtwJLaQhExEDgcWAwso1hLcTjF6MNRmbmqQ73vB35IMZX6zxQjHG8CVmfmIoDMXBIRi4ETyjZMBVYCPwY+UJY/rsJ3BWDo0P4MHbotQ4YMZtddd6KtbTlNTYMZMKAfTU2DAVi8uK3TMlJV7E+qB/ZT1QP7qeqFfVX1wH6qemA/3bQYNuoVMvMnEXEWcGFENGTmEqAPsCY8LNdfPBb4FfBvwFMU4eByilGJo2rrjIjDgVuAYyhG1B4DTAN2oJh6Xfv8v0TENsAbylMtmdkWESOBI4CXqn1j+MlPrmD06O059NDDmT59BuPHH8icOc0sX76SOXOaAbjyys7LSFVoahpsf9Imz36qemA/Vb2wr6oe2E9VD+ynPaN37140NjZ0fm0jt0V1ICI+AewBvA3YuTzdB1jdXiYz2zLzN5n5YnlqKLBj+bmCVwbZD1KEk8sppkdvTzEqchs6hI2l44HbKMLIayOiL/BHilGTlYeNRx11DPPnz2fKlBsYMWIEw4ePYNq0Kdxzz13cccftay0jSZIkSZKkv3FkozrzzcxshWJNxogYAPSiZmRjBzPLv7sp+lRrWX6NzJwPfDMiPg38EtidYg3GR4D9O6lzu8xcHhHPUQSfY8pntNINYeOIEY284x0nvezchAkTmTBh4jrLSJIkSZIk6W8MG9WZnSJiIkWotxh4PcUIxHERsTXQAPw4M2dHxGCKTWGmUOxa/Q8UI2bXNmq2N3Bo+bmk/P5A+8WyvvdTjI6EYip1c/nMsRRrQk6u6D0lSZIkSZJUIcNGvUxE9KMYcXhFZi6LiAZga2BuZq7uWD4zmyPi0vaRkMC/ljtU9++s/sz8as2zegNfAT7Xob7LgYaI6AM8DFyVmS+V9+xBEYBKkiRJkiRpE2PYqJfJzJXAT2uOl9BhF+pO7mntcPxwF5+1GvjXTs4vABaUhxd1uPZ4V+qWJEmSJEnSxucGMZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIq4W7U2iJcfO7Ra722vKV1rdckSZIkSZLUdYaN2iLMm7eE1avberoZkiRJkiRJmzWnUUuSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEr07ekGSBtDY2NDp+eXt7TSvHjZRm6NJEmSJEnS5smwUVuEM8+/ltkLXhkqTr7wBJp7oD2SJEmSJEmbI6dRS5IkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSaqEu1GrUhExFGjJzOVdKNsrM9s2QrO6ZPr0p7j55hs55pjjueCC8xk2bCgA55zzeVatWs1VV/2W7bffkdbWlRx55NE93FpJkiRJkqRNj2HjFiQihgADgBXAKGBbYBxweWbOXcs9Y4C9M/OP66n7y5n5eWAM8LqImAw0ZOasTsp+NDO/BRwbEc9n5gMdrg/MzGVrec52wG7ArVUHldOmTWHVqlUAnHHGhxk3bvyaa5dddglHHXUMo0Ztx6WXXkxzczODBw+u8vGSJEmSJEl1z7Bxy7IU+AZwFXAgcBnQf21BY2kOcFBnFyLiWGCb8nBMRLyHIrx8BDgamFX+tZfvBQwDGiPiMODtwN0RcTAwLzN/URbdNiI+A1wAnARsDTQD44FrgBlAf2C9oye7KvOv7LXX63jwwfs7vT5z5gs0NhavOmJEI4888hAHHtjpzyJJkiRJkrTFMmzcgmRma0TMpxjROJIicFxSWyYiJgBPUQR7dwFvAA6IiK2B+zPzrpr6rinv+QpwBfAw0EYxcnLv8v72evcFDgb6AdtTBIa3ZeZlHUcyZubTEfF1ioDxSmAv4Lmy3oeA3bsyTXtDzJjxDGPH7rMmbLzzztt59NGHWLRoEWeddTY77LATjz+e7L33WB5++EEGDBhQ5eMlSZIkSZI2C4aNW56HKUY2jgbmAYd3uH4McA9FWPgIRcB3S2b+qrPKImIsMJ1iROMo4Mny8/nyD4DMvDciHgB+Uz7/WGBQRHwUODIiTsvMRRHRQDGS8kagEfgqMBuYD+xetnn0a/wNXuaBB+5j3Lh9aW1tBWD48BFMmnQio0aN4uKLL2LmzBc48cR38pvf/ILp059i1KjtaGhwCrUkSZIkSVJHho1bkIjoA+wAvIkyRAR+ExHbAPMzczUwE/gtsAtwKLAdsGdE9AcGA9dl5lNlfQMpwsrFwDKKtRSHU4w+HJWZqzo04f3ADymmUv+ZYoTjTcDqzFwEkJlLImIxcALFtO+pwErgx8AHyvLHVfm7tLW10Nw8l7lz57Jw4VwWLpzFzjvvzJAhg9l1151oa1vOTjuN5OMfPxuAr33ta4wbtzdNTQaOqpZ9SvXAfqp6YD9VvbCvqh7YT1UP7KebFsPGLUS5LuI4ilGIbwaOoBh5uIpi7cMpFEHjSOBjwDTgQeDfgV7AH9oDwbK+XhSjE38F/BvF1OulZV3PUoxurH3+4RTh5jFA7/JzGkX4+bKNXjLzL2UA+obyVEtmtkXEyLLdL73W36PWuHEHAjBw4AsMG/YoU6fexujRz3DooYczffoMxo8/kPvue5QZM57lzW8+mLlzF7L11iOYM6e5ymZoC9fUNNg+pU2e/VT1wH6qemFfVT2wn6oe2E97Ru/evWhsbOj0mmHjFiIzbwNui4j9Kf7dnwP6AD/tsPPzeZnZClBu+PIjYE/gHcBPaupro5gSTUQADKUYBdm+ZmPHvvUg8F6KEZDDgCaKUZE30yFsLB1PsV7jYcA3IqIv8EegBdjpVfwE69TSspxp06bw8MMPcc45n+OOO25nypQbGDFiBMOHj2DlypVMnXoTM2Y8y/HHT6r68ZIkSZIkSZsFw8YtSEQcCOycmT+MiA9ShIfnRMS3MnMBFJvIlGWPppjqvBJoBW6NiL/LzF93UvXM8u9uij7VSjEaco3MnA98MyI+DfySYv3FgyjWhdy/kzq3y8zlEfEcsAcwpnxGKxWPbATo338Ap5zyHk455T0AvOMdJ73s+siR23LOOZ+v+rGSJEmSJEmbld493QB1v4joGxEnA62ZeWV5undmtgDfAM6NiL8r12UkIt4M3J6Z0ynCw9XlOo3DI+KDETG4pu7BwCyKadhPAgdQhIdr61u9KdaCHE2xE/ahwAO19UXE2RSjI6GYSj0GaADGAhPpsIO2JEmSJEmSNg2ObNwy9AF+XW4A075RzFKAch3GT9UWzszbaw77UoxuJDMv7lhxZjZHxKXtIyKBfy13qO7fWUMy86vt3yOiN/AV4HMd6rscaCjb+TBwVWa+VN6zB8WGNJIkSZIkSdrEGDZuAcoRjLXHq4DLunjvExHx5HrKtHY4friLda8G/rWT8wuABeXhRR2uPd6VuiVJkiRJkrTxOY1a61VuBiNJkiRJkiStk2GjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhLtRa4tw8blHd3p+eUtrp+clSZIkSZK04QwbtUWYN28Jq1e7qbYkSZIkSVJ3chq1JEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqRN+eboC0MTQ2NnR6fnlLK82Ll23k1kiSJEmSJG2eDBu1RTjz/GuZveCVoeLkC0+guQfaI0mSJEmStDlyGrUkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkSrgbtVSaPv0pbr75Ro455nguuOB8hg0bCsA553yeQYMauP76P9GrVy/uu+9ePvWpf+nh1kqSJEmSJG166iJsjIh3Azdk5uzyePfMfGItZT+cmd/rQp3bAyuBOUAjMBLYARiQmb/vYrt6AVtlZkvX3kRdERG9gWGZOX9jPnfatCmsWrUKgDPO+DDjxo1fc2327BdZsmQJJ574TlasWEFbWxu9evXamM2TJEmSJEna5NXLNOpewHKAiHgvEOspS0TsVX5uFRG7RMQxHcq9BHwd+AhwAbArMIoigFyviBgCvAdY1fXX2PxExKERcVKVdWbmamB8RBxQZb3rfuZf2Wuv1631+tSpN1F2KY47bpJBoyRJkiRJUifqYmQjsBpYHRHvAh7MzAfWUXZVRAwHDoiIScAiYCEwvEO5l4C7ganALsAIYBvgrvU1phx590ngvMxcVZ4bCrwdWAqcAkzOzJ92+Q3X/8y/Aoe1j+7cmCLiU8DewC+A/YH7M/MPERHAYcALVT8zM2+MiI9ExPy1jWKt0owZzzB27D48+OD9ANx55+08+uhDLFq0iLPOOpuZM2eycmUr999/L7NmzeLjH/+UgaMkSZIkSVIH9TKyEeAE4Lr2oDEiepWhH+XxMRHxf4D3UYR+TcAPgJ9QBIgvm5KbmSspRkHuTBFI/qb8fLYLbTkRmNoeNJZOB36bmb8G3g08suGv2Llyuvb7eiJoLN0NPJSZfwJ+BbwZIDMTuK0bn/tD4FPdWD8ADzxwH+PG7bvmePjwEUyadCKnnvo++vbty8yZL7B06VJ23nkMp576PnbffXceeOC+7m6WJEmSJElS3dlkRzZGRD/gDRSh4eHAM8BpEfES0Iei7dOA+wEy808RMQt4B9AGzKAIAOcCsylGMtbW35diRONc4HXA2cB4itBxfY6mGNlY6z7gSxHxlcycC9xbPucjwOPAAGBkZl4cEZ8B5mTmJe3fgcnAlcD/Lev6PvBpilGDbwHOKZ/b3v5jgMEUYekI4NbyPXYBbgYOBi7MzBkRcQgwhiJw3SYzfxIRn+6s7DreefeIOB44CfjM2gpFxJuA1wPTgbcC/w7sBvwvcCkwEGjLzO+X/8YfK3+rw8s2NLfXlZnLy1Gq3aqtrYXm5rnMnTuXhQvnsnDhLHbeeWeGDBnMrrvuRFvbckaPHknELjQ1DWbPPXdl0aJFNDUN7u6maQtjn1I9sJ+qHthPVS/sq6oH9lPVA/vppmWTDRszc2VEbAU8BvyFIog7ITOvWMdtE4DLKYLGMRSj8BooNn55qUPZ3sA1wBPAtZk5OyL6U0zZXp8+wIoO7Z0SEbOBL0fEIuDfM3M58HxmXhcROwBfAy4G7izbR/v3zJwXEd+g2KymBbg8M58ry1wfEe/r0IaTMvMfI6IB+HJmXh0RS4HWzLwyIhYCEyLiCuBDmXkaQER8LiL2pBjt+bKy5W+3Nk+Uz3gS+C+KILcz/YHfUax9eSqwfWY+FhHNwGWZ2RYRl1KEqWcA95S/XQMwFGjuUF+3z1UeN+5AAAYOfIFhwx5l6tTbGD36GQ499HCmT5/B+PEHssceY/nzn++isXF7nnpqBrvttjtz5nRsqvTqNTUNtk9pk2c/VT2wn6pe2FdVD+ynqgf2057Ru3cvGhsbOr+2kduyQTLzz5n5FNBKsRHLHyLi7zsrGxETgWuBXpk5BVgCvA3YHhhUHtfaDnggMx8H/jkitil3lf5gRIxeT9PuAvbqpL2PZOZZFKMUzy9PD42I0yhCxPVtPnMNxejFQ4Gb1lN2eTm9egjwXM35heXnCmArinUol9VcfxIYt5ay61VOnT5sHUVmA/8IvJFi/cr2PrYoM9vK7+2f44BHy3on14SrwJrRpxtlA56WluVMmzaFhx9+iMMOO4L58+czZcoNjBgxguHDR3DAAW9m9uwXmTLlBlpbW9ljj3XtUSRJkiRJkrRl2qTDxhp9KEKn5cDj5XTeNSJiAEWY9ViH+67IzOsoRjU215QfRDHleGhEjAEupAjv9qQYeXj2etpzKfCuDm04uWYNyVuAIeWO1Udm5iWZeT/FJjf9KEYuto8qbWyvoww724ARtdOJ1+IhirUjDwD+Zx3l5gL9ao7HAOvaYGedyt96+TqKfIliOvRNwGLWPXr2CWD3st5eEbFvh+tnAhe92rZuiP79B3DKKe/hP//zm4watR3veMdJTJx4JCeeeDIAvXv35owzPszEiUcyadIJG6NJkiRJkiRJdaeewsbXAwdl5j3A2Ig4LyKOg2Jtv8y8tyzbHqwNB86MiLMp1gOcU1Pf/wVuzcxHKKYPb5eZS4D9MnMFcO66GlNOj/5BRJxWji6EYmTg78uRl2cB36AIOZdGxN9FxEkUwdtEinUmj4iID1GEnrvV1HM1RRgJFDtfR8RRxdc4ugxKoVgH8SjgCIoRnFCsOTm+5vt+5WjCH0fE35ch7dPl6MRXlF3HKx8EjI+Io4F/Bf5P2bbXUaz3uH9E7F+WvRb4cEScSDGi9NSI2LVs/7Y137cDvge8PSI+QDGl+pma955YtvXmdbRLkiRJkiRJm5BebW1t6y/Vw8pNVmaVOz23bx4zAphf7ipdW/YDmXlpGYQ9mZktETGgDAjbywzKzJfK772Af6CYFv1G4IyO03nX0a5+wIAujEKsVERsDXw4M/+7HE35f4H/yswFG7Md3aV8p2GZOX+9hddvDDD9zPOvZfaCZa+4OPnCE1zbQZsE1xlRPbCfqh7YT1Uv7KuqB/ZT1QP7ac+oWbNxF+Dp2mub7AYxtTLzfzscrwReXEvZS8vPR2rOLe9Q5qWa723Aj9uPa6ZCd6VdK1n/OozdYRnQGhFvLZ//5OYSNAJk5mqKnbMlSZIkSZJUR+oibNyYyqBrk1YGpN/q6XZIkiRJkiRJteplzUZJkiRJkiRJmzjDRkmSJEmSJEmVMGyUJEmSJEmSVAnDRkmSJEmSJEmVcIMYbREuPvfoTs8vb2ndyC2RJEmSJEnafBk2aoswb94SVq9u6+lmSJIkSZIkbdacRi1JkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkirRt6cbIG0MjY0Nrzi3vKWV5sXLeqA1kiRJkiRJmyfDRm0Rzjz/WmYveHmwOPnCE2juofZIkiRJkiRtjpxGLUmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkS7kYtACKiX2au7Ol2tIuIvpnZ2v4d2Cozl1b5jEWLFjF58u/p168fq1evZs899+LLX/4CO+20M83NSzjhhJPYd983cvPNN64pc/zxb6+yCZIkSZIkSZsVRzZupiLirRER6ykzoObwAxExei3lBq6jju0i4tCI6NXJtdet5Z4hEfH2iPhCROyxlqo/1v6lDB3Pi4hK++udd95JQ0MDxx77Nu69924WL17Ed77zQ774xf/g2GPfxqGHHs7999/zsjKSJEmSJElaO0c2br4WAltHRD9gl/JvbGb+Z02ZYyNiSGb+GBiRmS8ARMTOQL/MfKIst21EfAa4ADgJ2BpoBsYD1wAzgP7A8g5tOAB4pP0gIt4MbAfsBtyXmV9cR/tfKu85AXgeeBw4JSKagOcz89cb8Ft06qijjmL27MUA9O3bj/32eyMAK1asYPXqVfTp04cJEybS1ta2powkSZIkSZLWzrBxMxQRfwfsBbQB/YBVwG3A7rXlMvO3EdEUEdsB+0TEORQh4h7ARTXlno6Ir5fXrizrfg5YATwE7J6ZLwsaI+IA4C/l917AUUATxWjaXYFdI6KxPF4NXJmZbWU4OgrYLSJOAfYEngb+AAwFdgKmvPZfqbBs2VIu+v/t3XmcXmV9//9XkslGZiYbw2LYVT4BBAIIyBIIi4BgBRWjoCgItFardfnWVmtrrVt/thZb64ISBRUtqAVFI7uRgCJbENk+soQlgZiFrCSZrL8/zplwZzJbkhNm7snr+XjkkbNc5zrXubms9c21XPo1Jk06ccO1W2+9icMPP7LLMpIkSZIkSdqU06j7oXLU343AI8AIioDuMIqwD4CIOLEMAYcA7wH+Cvhv4G7g8fIPEdEYEa8HninLfgl4IzAZOAo4gGLUZHv7Z+YjZXvWA/cD/wcsAJYB9wCzMvNHmXlVWQaKoPEQikDzZuCPFCMpJwKvAW6ucu3GHXYYwUc+8nF++9vpLFz4AkV7H2Xs2B27LCNJkiRJkqRNObKxn4mIoymCuvHAvcAMivUPv5GZ02qK/hk4DRgNLAe+CCwG7qPYjGUtQGYui4glwJlluduA1cD3KELKXwNvaNeG/aiZPl3WMy8iTi/ruBVIYO+ImFTbrsx8NiJeAywB3kURmL5YvvcVwBsi4uc14eQWW7x4McOHD6KxsZGDDjqAJ554mBNPPJHly5fQ0tK0ocygQRuXecMb3tBNzdKWaet3Ul9mP1U9sJ+qXthXVQ/sp6oH9tO+xbCxn8nM30bEBGAqcAzwAvB8Zs4HiIgJmXl/Zj4UEXMpAsepwH7AGIrp0fu0q/P3EbEjcFB5qbWc8rwTcALl+oo1XpeZ3207iYjRwLHACuBJ4EiKEZH7lPcPA27MzD+Wj+wE3AFcRzGl+0zgAeC1wH9WETQCXHvttQwZMoKTTz6Vp5+ezdFH78O99z7IunUDmDdvKQBXX30VY8aM2ahM2z2pSi0tTfYt9Xn2U9UD+6nqhX1V9cB+qnpgP+0dAwcOYOzYxo7vvcxt0ctjTPn3VZl5E7BTRAyIiH0opii3ORm4qjw+kmLtxDXAyogY0q7O0ynWfdwNuDEiGoBfUazZuCFsjIjdgafbPTskM68DngPeCTxPMU27OTP/OzO/3BY0lqMi7wcGZubs8vkfUazZOBsYUq71uNXOOOMMFi1ayK233kxTUzPjx+/HoEEDaW5u3lDm5JNP2aSMJEmSJEmSOubIxn4mIvaiCOteSbE79OMUU5dvodjg5RtlUNgM7JyZqyICirUQp0XE54ApFGsk3lJT9a6ZuTIiZlGMNtyLIjRcw8YjG0/KzMtr25SZfy4PVwA7UmxUs3d53t6QzPxDRBwXEZ8s2zG6/JalwHEUIx5/tFk/TAd23HFHzj77HRtd22efV/HBD350w/mYMWM3KSNJkiRJkqSOGTb2Pwdl5s8BImKXiHgTMCMzv1JbKCLeSbHhCxQjGpsBMvNT5f1jImIgxQYz76bYeRqKqdRLgUaKqdCjKcI/yhGHC7po21rgJooQczfgvPYFMvMP5eGgzPxCROxJMdX7R8C5wE/apoRLkiRJkiSpbzFs7Eciohn4fdt5Zs4Bfh6Fr1Csx5gUuzx/jWKXaoBngf+KiL8C1tf8uSUzn4+IHwKNETEIeAj4RWa+WL7z1RSbuQCcSLHjdGeGAd8B5lOsJTmri7LDI+JQYBzwrXKNyMuBr0TEBzNzdU9+E0mSJEmSJL18DBv7kcxcwkvBX+31BD7cwSNPlfdXA3/RRb0LgYXl6aXt7j1Wc/zjbpo4Dzi+7Zlu1l78H2BEZt5XU/9K4H3dvEOSJEmSJEm9xLBRL5t2oSWZ2emU68xcSjFdW5IkSZIkSXXC3aglSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIl3CBG24Upnzplk2srW9f0QkskSZIkSZL6L8NGbRcWLFjGunXre7sZkiRJkiRJ/ZrTqCVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUaersB0sth7NjGjc5Xtq5h6ZIVvdQaSZIkSZKk/smwUduFCz93I3MXvhQuXvflM1nai+2RJEmSJEnqj5xGLUmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkS7kb9MoqIAZm5fhvVPSgz126LuvurJUuW8Jvf3MrgwYNZt24dxx57/Ebnp5/+FyxbtoybbrqesWN3ZNGihbzpTW/u7WZLkiRJkiT1WY5s3AoRMTwi9oyIQyPiDRFxYURc0MUjn46Ibn/ziHhbRIyoqfuMbuoFuCAiBm/eFxQBaEQM3dzntqWIGBsRA7b1e/7wh/tobGzktNPOYMaMezc5B7j++l/w+tefxnHHTaK5uZknn3x8WzdLkiRJkiSpbhk2bp0hwHHAAOAB4HbguY4KRsRYYHlmrqu5NigiBnVQ/GDgjcCry/MXgGWdNaIMGYcBr42IsyPiQxFxTHeNj4hm4Fxgi0ZERkRzRHy63bXdtqSudpYCF0VEYwV1dWrixElMmnQSAA0Ngzc5B9hhhxHceecdACxevJgRI7ZpkyRJkiRJkuqa06i3QmYujoghwLOZOTci3gpM76T4+4AnIuIvgcEUv/0RwJXA1HZln8rMqyLibcD9wEhgdG2BiNgXmASsBNYAewO3Ao9m5sLu2l6OsPwo8Nm26dcR8WVgZmb+T0TsSRGevi4zZ3fw/OCy/UfVXBsHXAac1t37u5KZqyLi+8A/A5/cmrq6s2LFci699GtMmnRih+ennno6n/rUx7nrrjuZMOFQdt55l23ZHEmSJEmSpLrmyMatNygz55bHO9ccbxARBwLTgN8DLwLfAr4O/DIz2weNtcYA64DhwIraG5n5p8z8FrBDeakt/PuXHrb7LOC2dus83gpMKI8nAA90FDSW71+dmTcDc2quza493xqZuRK4PyLeUEV9ndlhhxF85CMf57e/nc7ChS9scv700zM57rgTOOqoY5g69TpWr169LZsjSZIkSZJU1xzZuPUGR8RoYCfgVRFxDkXo94XMnBcRo4A9gOszc21EnEoxErEJuKqbusdm5gsR8UqKkLIjw4DLMvOHAJux/uIpFCMba7XyUp8YCKwu63w/8Fj5rp0yc0pXFUfEX1AEpXtm5r+W1z4EPAUcBHy1HBV6AMXIyGeA/TLzv9pVdTvwMeBXPfymzTJkyDoGDRpEY2MjBx10AE888TATJ07c6PyRRx7hgx/8IIMHD6a1dRmZf+CEE07YFs2RaGlp6u0mSN2yn6oe2E9VL+yrqgf2U9UD+2nfYti4FcpNTHamWF/xeWBK+fdumTmvLLZTZv4yIt4aEQ9SBI2DgJMoQrSO1kts2xylbefqsRSBXEd2By4u134cTjGtuicGAas6uP50ue7iupprszPzpvL6v1N8Z2fGAr/OzGUR8eWI2B04EHg+M38eEc8AFwP/Afwj8K7MXFcGqu2tKr9pm/jBD65izJgxnHzyqTz99GxgNosWvbjh/Oij92HgwCHMn7+MhoYGhg9vZuXKdcybt3RbNUnbsZaWJvuW+jz7qeqB/VT1wr6qemA/VT2wn/aOgQMHMHZsx/taOI16K2TmeuA/gRkUwe2xwG7tyvwpIvYGhmZmltfWUASNn+1kQ5UxETEMmBsROwE7Ags6acZ/UUyhvoli7civ9rD59wDjO7h+BzCZjcPNkRFxPkWQ2N084gWZ2baZzRxgHPAaYGxETKIIZ/9c3h/WtmFOZn6jg7oOA+7t9ku20Mknn8KiRQu59dabaWpq5qyz3rrR+fjx+/HGN57J9df/gttum8af/zyHww47fFs1R5IkSZIkqe45snELRcSbKULAxRSh2uMUm8OsBY6pKbcjsHfbNOc2mbkyIv4VeC9FYFjraxS7RP+YIhBsovNp1LPLdy4FltS896jM/F0Xn3AF8AngwXbXf0cx6vArZT3NwEmZ+Z7yfF1EDM7MzkLHwTXHu1BMnd4VGJiZ08o62gLWtpGbREQAszLzxfK8ATgb+EAX37BVxowZy9lnv2Oja+3PR44cxRvfeNa2aoIkSZIkSVK/Yti4hTLzmtrzcm3G4ykCtGk1t0Zl5q3l7s+nUzOaNDOXsmnQCMV6ivdn5hLgroh4FPh8RMzIzMvblf1L4KcU/yxfUXP9CIrgsLP2r4yIy8oRi1eUozSPBP4E/IRid+u9KYLO5RHxlvLbGoBJETGdYiTnvhFxCnB3uQv27LLsYODhzJwTET8DPhER7ynruKFsxiUR8U/Ak8DKtpGf5Q7f7wX+OTM7muotSZIkSZKkPmjA+vXruy+lHomIg4C/y8zzOrm/C8XGMe/t4N4A4GCKjWbagrv2Zd6Xmd8sj3cFjgN+l5nPlGHmFRRrOLaWdXyqB20eTDGduc8scBARY4CFZQC6tfYCZl74uRuZu/ClDb2v+/KZrumgPsV1RlQP7KeqB/ZT1Qv7quqB/VT1wH7aO2rWbNybYlbrBo5srFBmPlCO3uvs/pyIuKiLKh4s13Ps7Plv1pwOyMyrau6tAzoMObtSTofubh3Gl1VmvtDbbZAkSZIkSdLmM2ysWNuGJ5t7vxzF12nQ2EH55zazaZIkSZIkSdI25W7UkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEm4Qo+3ClE+dstH5ytYe78UjSZIkSZKkHjJs1HZhwYJlrFu3vrebIUmSJEmS1K85jVqSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFWiobcbIL0cxo5t3Oh8Zesali5Z0UutkSRJkiRJ6p8MG7VduPBzNzJ34Uvh4nVfPpOlvdgeSZIkSZKk/shp1JIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoACKix30hIgZsy7a8HBYvXsx1113L9df/kqlTrwNgypRLufrqH3HDDVM3Kjtz5pNcfvllvdFMSZIkSZKkumLY2MdFxC4RcV4H14d38cyuEXFsR6FgROzfyWPHRMRJZZkOw8SIGFUeDomIvyuvDYqIvbp4ZpP3RcQrI2J8RLyqPD+/3f0t+rbNcffdd9PY2Mhpp53BjBn3kvkoQ4cOZfLkc5gx415Wr169oez06dNYu3bt1rxOkiRJkiRpu9DQ2w3QxiLiQODZzFwEkJlzIqKpg6I7l4HfvwFvBnYAlgITgOuBZ4GhwMp2zx0BPFzzvrcA64A9gZaI2BMYD3y8g3f+c0Q8DOwMtEbEB4HXAd8F5gPL2n3LscDz5fEg4DjgWOBu4HFg9/Lv9uHiln5bj5188snMnbsEgIaGwdx55x1MmHAYAOPG7c7DDz/EwQdPIPNRxo/fnz/+8Q9b+ipJkiRJkqTthiMb+56HgH+KiMaaa60AEfGKtguZ+RTwHxQh3NXAncANwF3Ag0BLZm4UxkXEEcDv271vJDANmAr8EUiK4LAjfwKmAyuA3wFzy7aNA8Z0UP5VmflEebw7Rcj4XGZeD6wGBpX3Vtc+tCXftiVWrFjOJZd8iUmTTmT+/PmMHj0KgObmZhYsKH6CZ599mt1332NrXyVJkiRJkrRdcGRjH5OZ6yLiH4GDylGGLcC4iBgCfBj4eBlEHgXcCowFvkQR/L0AvApYALyig+r3z8zL2117DngTMApYTxE4/jgiDgCezsza0Yo7Ax8Bvg78BUUgODozr2j/ooiYANxfHjcAk4AhFNO1x1IEj6+LiHHAseXU6W9SjFjckm/bbDvsMIKPfOTjXHLJl1i/ft2G6+vXr2fAAHjggfs5+OBDWLNmTRWvkyRJkiRJ6vcMG/umABYCTeXfhwLnAZ8GyMxlEbEEOBNYDtxGMTrwe8B7gF8Db9iowoj92Hj69MHAkRRTmEdQhJq7UUyzXlT+uQG4vSzfQNFffkYxXfpBiinUHY1oBDgkM79btndNRPwoM1sjYi3wC+BU4BHgWqAhM6eUz63e3G/bEosXL2b48EE0NjZy0EEHMH/+fGAVLS1NrFvXyitfuQcLFy5k6dL5zJ8/n0WL5rN8+QvsueeeW/tqqVMtLR2tmCD1LfZT1QP7qeqFfVX1wH6qemA/7VsMG/umAzLzh+WGLVMo1lNcnZkr2gpk5u8jYkfgoPJSa2auj4idgBOAF9vV+bq28K/0cPknKEYd/pliCvfBwLcy84/tnn8F8ADFeo6NwNsoRh+ujoj/l5n/0VYwIl4JPNbu+VdHxF5l28ZQrPN4GDC6/cdvwbdttmuvvZYhQ0Zw8smn8vTTszn66Incfvud7LHHvmQ+zpveNJk99ij+4zF8+HOMGvUIO+wwhnnzlm7tq6UOtbQ02b/U59lPVQ/sp6oX9lXVA/up6oH9tHcMHDiAsWMbO773MrdFXYiIEWUg1xQRoynWThwIrAWeiYjD2j1yOvBbihGJN5ajD39FMerwxZp6dweern0wM1dn5mpgDcV057UU6yPeSxE6trcvxTqNQyhGGj5IMSJyCu02hgGOy8zb211bSREy/j0wq3zfG4FDOvk5evRtW+qMM85g0aKF3HrrzTQ1NTN+/H60trZy9dU/5JBDDqOhoQgaW1tXMn36NB566EHmzJmzta+VJEmSJEnq1xzZ2Idk5osR8RmKKcNvBK4EhgHrMnNaRHw9IoYB95YbpOyamSsjYhbwamAvit2f17BxIHdSB2s1thlKsVbjbpm5JCKGZOa6DsrtnJk3l1Oc5wG7Aj8t721Y1DAidinb0N6K8s8Eiqnha4HrM/OmiLiwg/I9/bYtsuOOO3L22e/Y6NoFF1y8SbmhQ4cxefK5TJ587ta+UpIkSZIkqd9zZGPf82mKtRpvBvahGPm3qrz3BWAJMDQiPlBz/SCKMK4ROIBiWvQygHIzlgVdvG8BsBNwZ0S8FVjcvkC5eUvb6MUGYKfM/Gs63k36VIq1HtsbSrHG4ypgBjAAOCIi3kIRPLa9q6mn3yZJkiRJkqS+xZGNfUxmvgjc0XZertt4f3lvFsUUZCLih0BjRAyimPb8i/JZIuLVFKEkwInA/3X0rnKH6/2BlZl5c3ntnIj4t8z8h5qiewPXle9alpnXlNdvBD4O3Fc+OwxYlJnrO/iuJyPik5nZWpbdkWLn6xsppmi3lVu6Gd8mSZIkSZKkPmTA+vWb5ELaDkTEAOBw4P7MXNXu3tjM7Go0ZPu6BnYy9bov2AuYeeHnbmTuwg3763Ddl890AVn1KS5qrHpgP1U9sJ+qXthXVQ/sp6oH9tPeUbNBzN7AU7X3HNm4nSpHH97Vyb0eB41l+b4aNEqSJEmSJOll5JqNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2ChJkiRJkiSpEm4Qo+3ClE+dstH5ytY1vdQSSZIkSZKk/suwUduFBQuWsW7d+t5uhiRJkiRJUr/mNGpJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklSJht5ugPRyGDu2ccPxytY1LF2yohdbI0mSJEmS1D8ZNmq7cOHnbmTuwiJgvO7LZ7K0l9sjSZIkSZLUHzmNWpIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwsQciomkb1Dmg6jolSZIkSZKk3uRu1DUi4j3ASGAtMBb4M7AOOAR4fxfPHQMMzMzpHdwbBSzLzDXl+ZmZ+TPgnRHx+8x8rIdtGwAMyczWzfuq+hMRI4Hlmbl6W71j7dq1/OpXv6CpqZmZM5/g2GOP5/Of/zR77LEnS5cu48wz38zxx58IwMyZT/Kb39zK+edftK2aI0mSJEmS1C84snFji4HHgauA54DlwM3AQx0Vjoi23282MLSTOlcCX4iI0eX5nhExBHgFMDYiJnTXqIhoBs6lCEG3B0uAcyJil231grvuupOmpiaOP/4Ehg0bxv3338s3vvEdPvOZL3LaaWdw7LHHbyg7ffo01q7dXn56SZIkSZKkLWfYuLHlwCzg9PJ8PTCAIkzsyIURcRBwLPCGiPhARPwwInZqK5CZK4FLgB0i4p3A4cB7gTE17+tUGWh+FPjfmtGRb42IqRFxSkScGxFvryl/UkT8eLO/fON3Rg/KfCwivlse7xIRn+0uHIyIWyLikO7qzsz1wPeBD5XBbOV23nlnBg0atOH8da87hmHDhrFq1SrWrVu74V7mo4wfv/+2aIIkSZIkSVK/Y9i4sWHApcBF5Z8DgNPoZGQjsAcwhGI05PXAN4GfZObcduV2Bl7IzCspRk3uDlyamQ9k5vxu2nQWcFtm1g6tuxf4U2bemJk/BCbX3Ps98C/d1NmpiDiwfGd37gXWR8TBmTkHuKX8u7N6BwAfB/7Qk3aUgeO1wIU9Kb+59tnnVRtGLz733GzGjdsNgFtvvYnDDz9yQ7lnn32a3XffY1s0QZIkSZIkqd9xzcaN3QTck5nPRcSHgVuAcV2UfyYz74mIfYBXUgSUP2q7Wa49eDYwEfiHiDixrO8VwEkR0fb7X9Y2arEDp1CMbOxQWcfK8ngcxajMcZQBaUScXbbhGuAg4KeZeV9EjKcYkfkUsG9mfr18/iDggIg4GbgrM5d08f2foRi1+Zaa9mxSb3nrWOALmTmxLDcaeDNwHPAz4Ghgemb+vKb+e4APAd/oog1b5ZZbbuTtb38nAwYU+/VkPsppp50BwAMP3M/BBx/CmjWd/aORJEmSJElSLcPGjTUD50bESmB/YAbFqMXnI2KHzFze/oGIeD+wqix3Sm04l5mLgSkRsQMwlyI8eyXwl5m5OiJGZOaL3bRpUFl/e7tFxAnALsDfle+bHRE3AefXlLsHODYzr4qIGRTB433A3wPvzcz15TTokzPz5oi4A3h1Zt7cTbugmF7+aBlMtiVyHdabmdMj4oma32Yh8J2I+BDwQeA62o20zcx122oadUtLEw888AD77rs3EybsB0BrayvLly+hpaXYfHz9+laWLp3P/PnzWbRoPsuXv8Cee+65LZojAWzoe1JfZj9VPbCfql7YV1UP7KeqB/bTvsWwsRQRrwcOBFZQBGfzKQLH1wCDgUUR8f226czlaMYngMeAMynWYPx2J9UPoPitRwAnA60RMRQYTxe7XJfuKcs92O76rMz8dQ8/b1H59yqKad8ATeVUZcpvOI5iM5zN9f8BPwa+uIX13p+ZSzu6Ua4dmVvQpm4988xc/vjH5JRTTmPWrHk8+uij7LDDDqxbN4B584rmHHxwMZ16+PDnGDXqEXbYYcyGe1LVWlqa7F/q8+ynqgf2U9UL+6rqgf1U9cB+2jsGDhzA2LGNHd97mdvSl91KsTbi14A7gM+Vf/8SuCkzL2+3buIRZflngVbgkMyc2UndDRS7SZ8A/DIzLwX+h87Xgqx1BfC2LfmgbiyuOd4HuL88XkXZLyJir+4qKUdvTgX+opt6t8T7gf/aiuc79ctf/ozbbvs1n/70J/ibv/lLmpubGTRoIM3NzRuVa21dyfTp03jooQeZM6fTJSklSZIkSZKEIxtrNQHHUIwkfHdmfjwizs/Mj0bEv0fEFzPzBYCIGE4x8pGIOIdiWvLNEXFOZv6og7rXUkw5fgh4R0QcDgTlWotdycyVEXFZRJwPXFGOGjwC2DcixrS1qWzLOOAkYP+IOCIz7wImlOdDao6HApeUdT4H7JCZN5XVPA+MjYj3And30bSjKEaA3g58HfhEeb3DeiNiIrB3RLwRuLP8TY4G9omISZk5reY7BgDnAd/owQY6W+Tss9/B2We/Y5PrH/zgxstjDh06jMmTz2Xy5HO3RTMkSZIkSZL6lQHr16/vvtR2oJxG/URmPhkR4zPz0YjYMzOfjoiDgNmZuaAs+1qKoLaZYlOTFeX1fSjWT5xGsTvzJkFZRPwDcAPwZ2BuFxvDtH9uMDCssynH/UlENAMrMnN1BdXtBcy88HM3MnfhCgCu+/KZDrFWn+PQf9UD+6nqgf1U9cK+qnpgP1U9sJ/2jppp1HtTbBK8gWGj+ru9MGxUHfC/IFUP7KeqB/ZT1Qv7quqB/VT1wH7aO7oKG12zUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVcKwUZIkSZIkSVIlDBslSZIkSZIkVaKhtxsgvRymfOqUDccrW9f0YkskSZIkSZL6L8NGbRcWLFjGunXre7sZkiRJkiRJ/ZrTqCVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBR24WxYxtpah7e282QJEmSJEnq1wwbtV248HM3MmxoQ283Q5IkSZIkqV8zbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbKxQRAzo7npENJR/D3+52qWN3XLLjQAsWbKE6667luuv/yVTp163UZmZM5/k8ssv643mSZIkSZIk1S3DxnYiYscOro2MiEMjYlB5PqotNCzPzywP3xkRr+6g2pMi4vCIGAh8uKbsyG7a8q9b+A0DImLoljzbF0TE2M6C2611++23MXXqLwD4wx/uo7GxkdNOO4MZM+7dqNz06dNYu3bttmiCJEmSJElSv2XYuKlPRsRFEfHFiPibiPgB8CZgLNBUllkJfCEiRpfne0bEEOAVwNiImNCuzrnAAGAkMDgiTgCOAN4REWd10ZY5m9v4iGgGzgXqOSlbClwUEY1VV3zssccxZswYACZOnMSkSScB0NAweEOZzEcZP37/ql8tSZIkSZLU7zV0X2S781BmTomIdwNTgbWZ+f3aApm5MiIuAXaIiNOBw4FVwBhgOfBcuzqHADsAbwB2pAguf5GZP++oAeWoyd2AvSLinRQh5SBgYWb+oLOGlyMnPwp8NjPXltfeClwIfKV899rMvKq8dxLwvsx8W49+mY7fGZmZW/p8RzJzVUR8H/hn4JNV1t3eihXLufTSrzFp0okbrj377NMccMCB/PGPf9iWr5YkSZIkSep3DBs7Nzgz50fE6k7u7wxkZl4ZEYuBo4BLM3NmbaGImAycBCwGfgCsAI4Evty+wog4HjiwLDOn/PtXmflCD9t8FnBbW9BYuheYmJk3lu/4KXBVee/3bMHoyZr2HgicDvx/W1pHZ8pA9/6IeENm/qqqeltamhg2bDAtLW2DVJv4whc+y2c/+1mOOuownnrqKU48cSKrV69mxIihNeWkbc/+pnpgP1U9sJ+qXthXVQ/sp6oH9tO+xbCxc+vKv9cDRMR44DGgETgbmAj8Q0ScCIyjmEJ9Us1ajpdl5hrgpxQjHedlZpblvwZMAG6qfWFm/gb4TTlCcSzFiMmjI2J34ObMfKybNp9CMbKxQ2XbVpbH4yiCwnHAQ+W1s8tvuwY4CPhpZt5XfvuxwFPAvpn59fL5g4ADIuJk4K7MXBIR7y9/p2HATuUo0QaKtSofLt+5JDM/GRGHAK+lGA26OjOvbtfk24GPAZWFjfPmLWXlytXMm7eUJUuWMGjQQEaMaGSXXXbn5ptvo6Ghgfnzl/DCCwt44omnmDHjYXbbbfeqXi91qqWliXnzlvZ2M6Qu2U9VD+ynqhf2VdUD+6nqgf20dwwcOICxYzte/c41Gze1PiJGAcvK8yHl3zsC4zJzcWZOoRgxOBe4BxgK/GVmXgZ8PzO/WQaNlKMMG4C9yyDuQWB3YL+IOKj9y8t3vxc4jCKo/D3FiMnugkYoplqv6uD6buU6kW8D/q5s12zahZ3lt8wpp1lfAZxWXv97YEpm3gwsiYiTy+fvAJ7MzJszc0lZdnZm3gTMAE4ur50GPJqZUynCzv8or/9tZn47M68E3liGrLVWAdts1+7rr/8lv/vdHQC88MICXvGKcRx33CQOPfS1HHDAgeyyy64GjZIkSZIkSZvBkY2bGkARkv20PB8TEW2h3N8Bz9SUawBGlOVbyx2gxwPvb6ssIl4BHMpL6ziOpggypwFnRsShwDWZuRggMxdFxBiKkK1tZ+vXRsTFmdlRkFjrnvL9D7a7Piszf92DbwdYVP69ipeC1qbMXF8ePwYcB9zcyfMjI+J8irCxbQr6cxTTwwHW8FKQu0dETCqPH6L4LWv/dcRhFKFuZaZPn8Z9993DXXfdycknn8Ktt97ErbfeTFNTM+PH7wdAa+tKpk+fxkMPPcicOXPYZZddqmyCJEmSJElSv2XYuKlxwOWZuQ4gMz8PfL6Dcg0Uuz4PAn6ZmZeWI/P+uq1AOX34LODHwL7AAoq1HXcFjgcuApZnZmu7ul/MzK/V1PNXPQgaoRiN+Ak2DRu31uKa432A+8vjVZSjYyNiL+AF4KTMfE95bV1EDAZmA6eXG9L8pOZbns/MaWXZxzNzQ9BY/nZnAx+o8kMmTpzExImTNpyfffY7NikzdOgwJk8+l8mTz63y1ZIkSZIkSf2eYWONiNgROBU4MCIaKUbaDaIYxTgI+E5mXloWX0sRoj0EvCMiDgeCck1EgHIq9dfL02cj4ijgx5n5SESQmQs7aUpDRLyaYt3Gsbw0wrFL5aYql5UjC68oRyMeAewbEWNqN5op11w8Cdg/Io7IzLso1pHcPyKG1BwPBS4p63wO2KGcJg3wPDA2It4L3A08CyyPiLdQrHXZAEwCEngdxaY6CyJiVmbOAb4WER8r61kIzCrbNoRiKvk/9zBklSRJkiRJUh9g2LixhcA/AE9TTOdd0m5n5w0y87/ajstwbA1wK8U6jp0ZCkyOiHmUG890YjiwG8WIwkcp1m3skcx8NiKupNjIZmm56Ur7jVfa1mycUv5pu3YtcG15Wnv8IB2MlizDzPYjD/+65vgagIj4KPC2zFxRBrp/C/xTZv4W+G0Hn9FIsU5lV7+RJEmSJEmS+hjDxhplsDh9C577tx4W/S1wT2Yu66rQZtTX2fOreWm9xL7gLuAvIuLPQBPw864K147AlCRJkiRJUv0wbHwZlVOCt7tpwZl5e2+3QZIkSZIkSdvewN5ugCRJkiRJkqT+wbBRkiRJkiRJUiUMGyVJkiRJkiRVwrBR24UpnzqFla1rersZkiRJkiRJ/ZobxGi7sGDBMtatW9/bzZAkSZIkSerXHNkoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdgoSZIkSZIkqRKGjZIkSZIkSZIqYdio7UJj47DeboIkSZIkSVK/Z9io7cLQoQ293QRJkiRJkqR+z7BRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBRkiRJkiRJUiUMGyVJkiRJkiRVwrBxC0XE3jXHe0bEDj14ZvC2bZW6c8stN244njLlUq6++kfccMNUAB5//DEuuOBcPv3pT/DRj36Q3/zm1t5qpiRJkiRJUl3aLsLGiDgoIs6MiIsj4h8j4kMdlDktIsaUxwMi4uCI+EBEHN9B2YHAheXxIODdwMURMbKDsrUB4/vK8m3vGNLD9g+IiKE9KVvvImJsRAzYFnXffvttTJ36CwAyH2Xo0KFMnnwOM2bcy+rVq1myZDHf+MZ3+Mxnvshpp53Bscdu8o9ekiRJkiRJXdguwkZgHrAD0AwMBb7eQZk9gCURsSNwKnA+8I3M/E0HZU+vqeNU4HLgV8COHZR9b0S8OyIuBBrK8wuBbwPHdNfwiGgGzgXWdle2n1gKXBQRjVVXfOyxxzFmzBgA7rzzDg48cAIA48btzsMPP8Shh76WYcOGsWrVKtatW8ugQYOqboIkSZIkSVK/1u/DxnIU4qsoQsYbgbuA95cjHYfVFF0LBPBKYCWwE8VoxQ9HxGtq6hsE7FwenwqcDJwH/AtwZURcUVN2FDASuLJ8/1eB0cAfgK9l5q970PaPAv+bmWvKayMj4l0R8ZaI+N+IeOcW/TCdv/PRiNipyjo3R2auAr4PfHJbvmf+/PmMHj0KgObmZhYsmL/h3q233sThhx+5LV8vSZIkSZLULzX0dgO2pXKa8oXAEOB4YAnFCMYxwCjguohoAt4FHEIRNv4YOAD4LDAhMy9tV+1HgIXAp4A7KX7Dm4BW4J2Zub6m7BKKUY/vB44sz3eiCCBv68EnnAXclpm1oxovAC7LzGURcQ0woQf19Eg5ffldmTm3qjq3RGaujIj7I+INmfmrquptaWli2LDBtLQ0MXz4YEaPHkFLSxONjUMZOXI4LS1NADzzzBOcd947qnqt1GNtfVDqy+ynqgf2U9UL+6rqgf1U9cB+2rf067AxM1dFxM3A24EfAr+kCP72AX6cmeuApRHxbYrAcRDwR+A1mfloRMyLiLMz8yc11X4FOAiYQzECMoDPAbsBEyPis5l5b/n+dcDciPgzxSjSERRBZzMwDFjdzSecQjGysdb9wL9GxBcycz4wAyAi3g88Vta7U2ZOiYj/B+wN/AY4GvhyZj5bjshsAvYs23MHcD1wIvDx8r2U9R4D7AW8AOyYmd+PiLOA9wFvpJhuPjwzvxoRhwCvBZYDqzPz6jLAvBCYDZwNXJmZt3ZUtt133g58jGJ6eiXmzVvKypWrmTdvKSNGjGTmzNk0NbXw3HNzaWkZx7x5S2ltbWX27DnMm7e0qtdKPdLS0mS/U59nP1U9sJ+qXthXVQ/sp6oH9tPeMXDgAMaO7XgFvH49jboMug4E7gMagQ8AN2Xmu4CsWRdwJMWow/XAGcCyckOWtwODIuIjEdFSlh0KnESxtuATwJ8oQrf/zMyzyne1vX9YRLyHYr3I1cA6ioB3V+CdEXFoN58wCFhVeyEzpwGXAZ+PiC/VTAWfnZk3UYSPJ5fX7gEeK4O8qcDE8vqbywD1UqAxM6dm5rrMvBl4rt3vd3FmXlmOMNw9IvbNzGuBOeXU7kWZ+dXykb/NzG9n5pXAG8tp4E0Uoy9vBi4GnumibK1VwPBufp8tduSRR/Pggw8AMGvWs+y/fzFT/plnnmbIkB7t2yNJkiRJkqR2+nXYCLyeYtryrhQj+E4G3hYRFwMnUIz2gyLYagGOA24ARmVmK7AqM6/KzEsyc15Z9jxgMPAU8DSwH/Al4NyI+CpweNvLM3Ml8AOKoPEfKMLMiylCxG9l5oZgshP3AOPbX8zMhzPzr4DrKEZVAoyMiPOBsWw8YnJRzTe2pWgryyCxGZjVxft3BFbUnD8BHFwePxoRrwbW1NzfIyImRcQk4CFgRGYuAa4GvgV8puZ9m5Rt9+7DgHu7aNtmmz59Gvfddw933XUn48fvR2trK1df/UMOOeQwGhqKQb6DBg2kubm5ytdKkiRJkiRtN/r1NGqKdRF/A4wDzgF+RhGYLcvMO9sKZebSiFgCfI9i5+fWLur8FnAsxRqQDxSP53cj4qLMvKwM8YANG7y8iWI37DcBR1AEjc8AX4yI64F7y0CuI1cAnwAerKnzbOD/yinatwPnlTtWn5SZ7ynLrIuIwV18w4MU60GuB/6ri3LzKYLVNnsB15bHVwP/CPx7zf3ny5GXRMTj5e96AHBfZt4WEROA91Ls5L1J2ZpvbKCYcv2BLtq22SZOnMTEiZM2nF9wwcWblNlnn1fxwQ+2n7kuSZIkSZKknujXYWO50cjxwG6Z+fkyELw5Ik6JiH+lWKfwEWAXYFZmTo+Ie3lpunFHv891wPcy8/sAEfGhiLgIGBcRHwaWR8REiinThwHX1ewkvaZcS3Ek8DCwjGI6dlftv6wcsXhFufnMEODnEfF9ip2t/xt4sXzvWygCxAZgEsVGN3uV1U2gWKvycoodtw+hGJU4ALimDEZPLJoZpwB3ZOaLEfG9iHh72c6nMjPLtj1Zfs+jNU3+WkR8DHieYhOdWRQjFn8QEZdRrCf5my7Ktm3q817gn8udqSVJkiRJklQnBqxfv777UnUqIk4Gnm0LyCLifZn5zfI4KKYIzwPGZ+aMiBhEMeLvmsxcFxHvLNcUrK2zoS08LM8/QhEEvtBJGz4A7EsxQnAcRQjZCtycmZf18DsGA8NqR/9tqYjYAfjLzPxKGTD+C3BJZi7c2rqrEBFjgIXtdvXeGnsBMwEXjFWf5qLGqgf2U9UD+6nqhX1V9cB+qnpgP+0dNRvE7E2x1OAG/X1k483tLn275l7WXJ9Rc3xNOUWZ9kFjeW1Nu0vfyswXu2jD13re4k7rWE33O1f31ApgTUS8vqzzib4SNAJ0FtpKkiRJkiSp7+vXYWN7mbl2a+538kynQWNfVI4Y/J/ebockSZIkSZL6n/6+G7UkSZIkSZKkl4lhoyRJkiRJkqRKGDZKkiRJkiRJqoRho7YLra3t9/WRJEmSJElS1QwbtV1YtmxlbzdBkiRJkiSp3zNslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBs1HahsXFYbzdBkiRJkiSp3zNs1HZh6NCG3m6CJEmSJElSv2fYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYKEmSJEmSJKkSho2SJEmSJEmSKmHYuB2IiOaIGNbb7egLbrnlxg3HU6ZcytVX/4gbbpi6UZmZM5/k8ssve7mbJkmSJEmSVPcMG+tMRBwQEUPL49d3US4i4pDy9Bjg8M18z4C297zcImJYRIyout7bb7+NqVN/AUDmowwdOpTJk89hxox7Wb169YZy06dPY+3atVW/XpIkSZIkqd8zbKw/bwdeUR7v11mhzEzg5PJ0GHBXROzWkxdERDNwLtAriVtmrgROiYiost5jjz2OMWPGAHDnnXdw4IETABg3bncefvih8t2PMn78/lW+VpIkSZIkabth2FhHImJPYG5mziwvrYuIiRFxeE2Zhoh4X0S8H1gUEf8J7AJMBl4dEV3+My/vfxT438xcU3P9byPi3RHxXxHx7qq/rb3MvAY4OyLGbov658+fz+jRowBobm5mwYL5ADz77NPsvvse2+KVkiRJkiRJ/V5DbzdAPRMRg4DzgfsiYiKwP/BqYBrwTFu5zFwTEd8BTgV2BMZQjFAcCtyRmeu6edVZwG2ZuWFUY0QcB6zIzO8B34uIoyv6rO58B/gY8MkqKmtpaWLYsMG0tDQxfPhgRo8eQUtLE42NQxk5cjjPPPMnTjxxIqtXr2bEiKG0tDRV8Vqpx+xzqgf2U9UD+6nqhX1V9cB+qnpgP+1bDBvrx1uAK4EDgFnAemACcCRwfETck5m/L8uuBp4EngcOAdYBA4CLI+KOzLy/i/ecQjGysda7gM+0nWTmbwHK0ZOPUUzT3okiHJwOfB34C2AqRSD6OeAjwF1l++/MzHsi4p+AURRh4hTgG5l5R817no+IfXr06/TAvHlLWblyNfPmLWXEiJHMnDmbpqYWnntuLi0t43jqqeeYP38JL7ywgCeeeIoZMx5mt912r+r1UpdaWpqYN29pbzdD6pL9VPXAfqp6YV9VPbCfqh7YT3vHwIEDGDu2scN7ho11ICJGAtcBO1OMUnwV8DjweGZOaVf2OOBg4DlgNkXw2FZmdGa+0M3rBgGr2l3bHZhb1v8O4EDg34HZmXlTuRbkv2fmlIh4HLgKOC0zvx8R36UYVXkXcFtZ3+nAPcCXyudaI+Km2qCxxjaZ6n/kkUdz3313c9BBE5g161nOOec8GhqK/zg8//xzPP30UwaNkiRJkiRJm8k1G+tAZi4uN00Z/bNxYwAAGsRJREFUDKwEfl3+PTYiJkfEiTXF7waWUwSTJwJjgX8ALgCOiojuAuZ7gPHtrs0v6wH4PTAiMxcBIyPi/PLehu2cyynYbdO1BwAvAkcAb6YYkTmwLNcKrI6InYE57RsSEaOBhd20t8emT5/Gfffdw1133cn48fvR2trK1Vf/kEMOOWxD0NjaupLp06fx0EMPMmfOJk2SJEmSJElSFxzZWF8aKEY2HkwRJq4AfpWZG8YLZ+aKiLg6M5eW05QvBt4P/Dwz5/fgHVcAnwAerLn2M+D1wPfbLpQ7Vp+Ume8pz9dFxOBO6nwDMD8zfxIRe5XlB2fmauB64J/ZdOo2wIeAS3rQ5h6ZOHESEydO2nB+wQUXb1Jm6NBhTJ58LpMnn1vVayVJkiRJkrYbjmysLyPKPy8CS4FxwNsi4qKIuDAihgKUQeP5wP+Vgd4U4NsR8drudqMuR1BeFhHnR8SA8vL/Uexk/W6KDWSmlm1YHhFviYg3UwShJwJ7RsRrgFdGxHjglcAfgQkRcRZwFLAbxVRsgFuBdeUoxw3Ksjdk5qNb8kNJkiRJkiTp5Tdg/fr1vd0G9VBE7EexEcswih2on8vMxe3KvAo4lGJH6Tk11/cHfgM8BVyUmX/o5l2DgWG1oya3hYjYAZiUmVNrrg0DGjJzWQWv2AuYCbhgrPo0FzVWPbCfqh7YT1Uv7KuqB/ZT1QP7ae+o2SBmb4qsaQOnUdeRzHwEeKSz+xExCFiamVd38OzDQMtmvGs1NeswbgsR8SGKTvn37d69clu+V5IkSZIkSduGYWM/Um7M8ufebkdPZeZ/93YbJEmSJEmSVB3XbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGbRdaW9f0dhMkSZIkSZL6PcNGbReWLXODa0mSJEmSpG3NsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFGSJEmSJElSJQwbJUmSJEmSJFXCsFHbhcbGYb3dBEmSJEmSpH7PsFHbhaFDG3q7CZIkSZIkSf2eYaMkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSaqEYWMfFREDersN/dEtt9y44XjKlEu5+uofccMNUzstI0mSJEmSpJ4zbNwKETE0InaJiIMi4uSIOC8iRnXzzIgoXBgRg7so+tEtbNOAiBi6Jc/2BRExLCJGbIu6b7/9NqZO/QUAmY8ydOhQJk8+hxkz7mX16tWblJEkSZIkSdLmMWzcAmWgNxJ4L/A64G3AE8BVwIqIeE1N2ZaI+JuI+OuIeB/wVmB3YK/MXN1J/ScAO0fEZv3ziYhm4Fxg7ZZ812a+a3D5TXtWWW9mrgROiYiosl6AY489jjFjxgBw5513cOCBEwAYN253Hn74oU3KSJIkSZIkafMYNm6Z/YG/pAj1dgX2AE6lCB//E9i5rWBmzsvM/8nMbwBXA48B9wBzOqo4InYAJgCfBs7saYPKYPKjwP9m5pry2mERcV9EnBoRH4yIt9WUj4j4Xc8/eROHAZOAjaZ7V1AvmXkNcHZEjN2aeroyf/58Ro8eBUBzczMLFszfVq+SJEmSJEnabjT0dgPq1BspRjEeDDwDrACWAqOASzLzcdgw0vAdwEpgPbC4LL+mPO/IBcC1wJHAXRFxWmZe34M2nQXclpkbRjVm5r0R8Uxm3gDcEBHXAj8ub88E/rpnn7upzLwzIh7p4NZW1VvjO8DHgE9WUBcALS1NDBs2mJaWJoYPH8zo0SNoaWmisXEoI0cOp6WlCWBDGenlZr9TPbCfqh7YT1Uv7KuqB/ZT1QP7ad9i2Lhl/gdoAZopfsNRwMLy3rq2Qpm5JCJ+CBwArKYYATk+M++PiI3CxnJDmAuAqzJzfkSckpnTImJcRFwAfL9txGInTqGLdR4jorGtjeWIwWOAtwDn15R5KzCIYrTmtMz8Q0TsSjFqcz7w98CJXUz/3qTeiHgt8EXgcorp4w9k5tSI2As4vWzTIcDzmXlJzW/3fETs08X3brZ585aycuVq5s1byogRI5k5czZNTS0899xcWlrGMW/eUoANZaSXU0tLk/1OfZ79VPXAfqp6YV9VPbCfqh7YT3vHwIEDGDu2seN7L3Nb+oXMfBEYCzxMMR16Qfn3YmBcu+LLgXcDIygCu7agbkPYWE6BficwFdg3It5SXv8qRZj5AvC2bqYVDwJWdXB9x4h4O/CvwP8r278gM39eW6is++jMvJoiTG0LLg8B1mbmLyhGaXa6qU1H9WbmPcCLmXklxRTzs8pbfwN8LzN/BOxYGzTW2Gb988gjj+bBBx8AYNasZ9l//9d084QkSZIkSZK6Y9i45fYC3gCcABxNMaJxPe02Z8nMdcDjwHMUazEuKW/VjmxsplhrcQ6wCJiemZcCs4HfZebPMvNHmbmgi/bcA4zv4Pp84P+A3bp5/pXAiIiYBEwEHizbPxVoiIgfAKdm5vIu6ujMorKuVcCQ8tosYMfyeHH7ByJiNC+NFq3E9OnTuO++e7jrrjsZP34/WltbufrqH3LIIYfR0NCwSRlJkiRJkiRtHqdRb7nFwH0UU453oAgf1wFP1RYqN3zZB3gNcDfFrtVQEzZm5qKaR2YCwyPiRODKzOxsbcf2rgA+QRkS1srM1RHxcEQclpn3dvL8U8DyzJxWtrtt3cnXZeZ3ge9GxIcjYv/MfLiHberK/cDrI+I54N87uP8hoKPRjlts4sRJTJw4acP5BRdc3G0ZSZIkSZIk9ZwjG7fcCuDPFDtMP0sRIu4BPF9bKDOXZ+YHy9GJvwdWlWsRDmhfYVl+BXAUxZTmZ3vamMxcCVwWEeeX6z8SEYcBu0fEzsA3gU9FREtEjI2IM4B9IuK48vm5wP0R8b6IOAfYqax6YkR8MSJOAV6kDFMj4hhgP+DktrUVO6o3IiYAe0dEc3m8T0SMpJiGfjxwGsXO0xumZ0fEWcANmfloT79fkiRJkiRJvW/A+vU9HTinWhFxAvBdivUaF5d/FmTmRT149iTg+Mz85y7KvJVi05Tfbma7BgPDMrNPr44aEf+YmZ8vj18PNGbmNRExDGjIzGUVvWovitGiLhirPs1FjVUP7KeqB/ZT1Qv7quqB/VT1wH7aO2o2iNmbdrN8nUa95X4HHNbNOogdysxbIuI33ZT56ZY0qtwpusPdovuYJ8pRkEsppqL/EjaM0JQkSZIkSVIdMmzcQmUotsXBWGauqbA5dScz/7fm9LZea4gkSZIkSZIq45qNkiRJkiRJkiph2ChJkiRJkiSpEoaNkiRJkiRJkiph2KjtQmvrdr1EpiRJkiRJ0svCsFHbhWXL3ORakiRJkiRpWzNslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlTBslCRJkiRJklQJw0ZJkiRJkiRJlWjo7QbUk4g4A7grM+dFxKnA3Zn5QrsyI4BTM/P/yvO9gebM/EMndb4LuBM4HfgFcFJmfnsz2jQAGJKZrVv0UX1UROyYmfOrqGvt2rX84hc/Y8SIJmbOfILzz7+IKVMupampmZEjR3LqqadX8RpJkiRJkqTtniMbN88EYFHN+f61NyNi18x8ERgTEadHxM7AMcABHVUWEScCewLPAo8AfwOsjYj3RcTw7hoTEc3AucDazf+UbS8iBkfETt2UaY6IT3dwa6+IOLmKdtx+++00NjZx/PEnMGzYMO6//z6GDh3K5MnnMGPGvaxevbqK10iSJEmSJG33DBt7KCKOBX6XmW3J1AJgWbtiR0bEQcA6YA/gQOBhYFFE7NquvuMpQsLHgZ2A+4EHgNsy85vAYd20ZyDwUeB/M3NNeW33iLg2Is6IiMkRcU1N+ZMi4sc9/NbXRcQFEfHOiPi7njzTiY9TjNjs7D2DgSOAo9rfy8x7gFERcfRWvB+AXXfdlUGDBm04v+++ezjwwAkAjBu3Ow8//NDWvkKSJEmSJEkYNvZIRAwCLgLmRMR+5XnbvaaIeG15+kuKoHEc8Gtg58y8D7gBeFe7au8GnuKl0HJ4ee2zEfFh4JRumnUWRTBZO6pxOHB2Zv4SOBL4RM293wP/0oPPBXgvcEVmXgl8uYfPdOSOrm5m5urMvBmY08n9nwAXb8X7Adh3332ZOPF4AJ57bjYLFy5k9OhRADQ3N7NgQSWztSVJkiRJkrZ7rtnYM28GfsRLIxb3BuaW91qBY4F7ynITgRZgL2BJRBwOvAaYEBEfAb6VmS9m5vJyZN/5wCuBAF4AHsrMr/SgTadQjGzcIDP/BBAR+wIDMvPR8nwcxQjDccBD5bWzgbOBa4CDgJ9m5n0RMYliaveJEbE0M38fEfsAZwB/BE4E/gNoAn4AfKf8XfbMzC+Ua0h+iiJIDYqRm0TEIcBrgeXA6sy8ugffCLA6Ipoyc2kPy3do7NhGpk6dyvvf/1d85zvfYfToEbS0NNHYOJSRI4fT0tK0NdVLlbAfqh7YT1UP7KeqF/ZV1QP7qeqB/bRvMWzsRrnhy90UAdw6ikBwDS/9djsCCZCZV0fEnsBgimDvRYqQbzpwSTk1uNYg4ApgNDCfzVt7cRCwqpN7/wh8rO0kM2dHxE0UwWabe4BjM/OqiJhBETzel5nTIuL8csRhmxEUm9fMoViDckJm3hYRc4GrM7M1Iq4oy74JeDIzryyDy73K63+bmecDRMT3IuInmbmuB9+5imLE5laFjdOn38mwYc0MGzaKESNGMnPmbJqaWnjuubm0tIxj3rytql7aai0tTfZD9Xn2U9UD+6nqhX1V9cB+qnpgP+0dAwcOYOzYxo7vvcxtqTvlKMSnKX6rjsKxnYB5UKx1CPwKuBe4nCIouxLYGXisg2d3Bm4ErqKYpj0GuLt2mnYX7gHGt78YEScAf+zhTs6Lyr9XAUO6KPdn4DzgeGAlL/WbFTW7YK8v/x4P/KmDOvaIiEllAPkQRYDZEztn5tzui3Vu+fLlzJr1LAceeDCtrSs56KAJPPjgAwDMmvUs++//mq2pXpIkSZIkSSXDxp4byEuBWq1dgAXl7tFNmfkgxRTmdcArMvNxYERmLq59KCIuAL5Qc2lvinUYPwt8tZz63JUrgLe1q3Mg8AHgq+X54T38tu78HXBlZl5PscbkgC4C0aeAts1wxtZcfz4zp2XmtLKubv+1Q0ScAVy7pY1u89Of/pTf/ObXfPrTn+Bv/uYvGTVqNK2trVx99Q855JDDaGhwgK8kSZIkSVIVTFl6roGX1mw8mGKK9DqKdQk/BJCZN5WBH+WmMXdFxCl0HFJeRzFt+j0UU7RvBw7PzDsi4szMnN1VYzJzZURcFhHnU2zmsh54NzALmBgRuwH7U4yUHAecBOwfEUdk5l3AhPJ8SM3x0PKZvSPijcD9mTkLuBU4JyIepAhX9wceKT4z9il/i30j4pXA/wGfLut6FTC8XMfxaxHxMeB5YCEwKyKGUax3uW/5O92dmQvL3+9QipD2yi7/qfTAeeedx+mnv5l16176x7D33vtsbbWSJEmSJElqZ8D69R3lYGqvDMMeBBZn5os11zfavCQixlBMOb6nDA5fB4zOzF+1q+8IoDEzb42Id2fm9yLiImAKxUYzv24L3rpp12Bg2NZuoNLXRMSOPZwK3p29gJkLFizbKGyU+hrXGVE9sJ+qHthPVS/sq6oH9lPVA/tp76hZs3FvilmuGxg2bgMRMaAcaajetxeGjaoD/hek6oH9VPXAfqp6YV9VPbCfqh7YT3tHV2GjazZuAwaNkiRJkiRJ2h4ZNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqhGGjJEmSJEmSpEoYNkqSJEmSJEmqRENvN0DaxgYBDBw4oLfbIXXLfqp6YD9VPbCfql7YV1UP7KeqB/bTl1/Nbz6o/b0B69evf3lbI728jgWm93YjJEmSJEmS+qGJwO21Fwwb1d8NBQ4HngfW9nJbJEmSJEmS+oNBwK7A3UBr7Q3DRkmSJEmSJEmVcIMYSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSZIkSZIkSZUwbJQkSZIkSZJUCcNGSdoGIuJNETGqt9shSZJePhHxy95ugyRJva2htxsgbSsRcTEwDNgV+K/M/HMvN0nbiYg4CvgicEx5viPwCeBRYGBmXlpe36SPbk7Zl/er1N9ExBDgAmAOcAhwFTAP+6r6kIgYDfwVkMDrgK8DL2I/VR8UEacDI8tj/7tffVJE3AzML09/AkzDvqo+JiImAjsBhwJ3Ar/DflpXHNmofikidgfekJlfBS4HPt+7LdL2JDN/B9xdc+kLwJWZ+W3gmIjYs4s+ujllpa1xGjA0M38GXAa8D/uq+p5BwF2ZeQ1wD3AE9lP1QRGxA8X/iG0Lceyn6nMiYjDw35n5jvLPT7Cvqo8pZ4edlpk/BT4N3Ij9tO4YNqq/OhX4LUBm/gk4unebo+3ccZl5X3l8P/B6Ou+jm1NW2hrTgVvK472Bh7Gvqo/JzPmZeWtEnAccnZk/xn6qvulM4Oc15/ZT9UWjgddFxN9GxDcj4hXYV9X3nA6MjYiPApcAh2E/rTtOo1Z/1UIxHbDN0N5qiAQMqTleAuwIDKDjPro5ZaUtlpkLgYURMQKYBPwb8Pc1Reyr6jMy8/sR8eeIuAD/b6r6mIjYC5iVmWsiou2y/VR90YvAZZn5ZESMBz6MfVV9z27Aisz8z3I07pXYT+uOIxvVX80FRtWcr+yldkgArTXHzRT/RddZH92cstJWiYhG4Fzgi5m5Gvuq+piIGBYRu5WntwFnYz9V37M/MCgiJgE7ln/bT9VXLS//fpIi1LGvqq9ZAcwEKP//04HYT+uOYaP6q5soFpKn/Ld2t/duc7Sdmx4Rh5THh1KsO9JZH92cstIWKzeIeSfwnXI0zvHYV9X3nAJ8sDweBzyG/VR9TGZOzcxpmTkNmF/+bT9VX3Q2cE55vA/wCPZV9T2/A44EiIiBFGvh2k/rzID169f3dhukbaLcbWooxf84uSQz5/Zyk7SdiIjjKHZMvYJiAWIopqc+BqzPzG+V5TbpoxHR0tOyL98XqT+KiL8FTqD4N7vDgIeAr2BfVR8SEcMpwsYngFdTbGY0APup+qByRON3gY9RrItrP1WfEhFNFP+icS6wH/ANio247KvqUyLi08DzwBqKmQ2LsZ/WFcNGSZIkSZIkSZVwGrUkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkShg2SpIkSZIkSaqEYaMkSZIkSZKkSjT0dgMkSZKkehQRRwHfA94PDAYuAH6amf/bqw2TJEnqRY5slCRJkrZAZv4OmJ2ZN2XmVODtwKjebZUkSVLvMmyUJEmSKpCZ64Bv9XY7JEmSepPTqCVJkqQKRMSbM/OabsqcCywCWoCLMnNief0UYBdgPnBYZn62vP5WigECK4FdMvPbEXEI8E5gZlnX0cBNmXltRJxe1r0eGJiZl1f9nZIkSV1xZKMkSZK05UZFxKSIOAd4TQ/Kvxn4Q2ZeAXwMICJGAu/NzO+V07Fby+v7AEdn5o8z8zqgMSKOy8wZwC+AI4EfAR8FpkbEKOAtmXlFZn4POC4iWqr9XEmSpK45slGSJEnacosycxpARBzUg/IfAz4WETsBV5TX9gWeaiuQmV8qDw8FHqt59hHgCOC28vzWcup2Wzh5MDAsIiaV9x8EGoF5m/VFkiRJW8GwUZIkSapAZj7Q1f2IGAzslpkfjYhBwE8i4m6K6dB71pQbSbHRzB8odrhu80rgvi5e8SSwpib8fAz48+Z/iSRJ0pYbsH79+t5ugyRJklR3IuJY4DLgjMx8oofP/BH4EkUI+JrM/M/y+rnAK4DnKZY6+kFmro+IycBqitGLu2bmlIjYD3gLxRqPV2bmnTX1TwZ2plj7cUVmXlvJx0qSJPWQYaMkSZIkSZKkSrhBjCRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRKGDZKkiRJkiRJqoRhoyRJkiRJkqRK/P9tb8bHoHIIOAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x2160 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "### 特征重要性\n",
    "from pylab import mpl \n",
    "mpl.rcParams['font.sans-serif'] = ['FangSong'] \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from xgboost import plot_importance\n",
    "fig,ax = plt.subplots(figsize=(20,30))\n",
    "plot_importance(model,height=0.5,max_num_features=64,ax=ax)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                     feature  importance\n",
      "3                   keyword       59590\n",
      "2                   alcohol       38028\n",
      "0                      year       25276\n",
      "7                      葡萄品种       23926\n",
      "6                        特性       22795\n",
      "5                        口感       21337\n",
      "15                      原产地       17243\n",
      "14                       产区       15479\n",
      "9                        颜色       15012\n",
      "1                     国产/进口        9581\n",
      "8                        甜度        5006\n",
      "12                       其它        4988\n",
      "16               梅洛（Merlot）        4177\n",
      "17     西拉/设拉子（Syrah/Shiraz）        3419\n",
      "10  赤霞珠（Cabernet Sauvignon）        2465\n",
      "4       品丽珠（Cabernet Franc）        1855\n",
      "11                     白葡萄酒        1364\n",
      "18                    桃红葡萄酒        1281\n",
      "13  蛇龙珠（Cabernet Gernischt）        1027\n",
      "23           佳美娜（Carmenere）         873\n",
      "26          霞多丽（Chardonnay）         809\n",
      "19                     红葡萄酒         515\n",
      "21                    果味葡萄酒         459\n",
      "27     长相思（Sauvignon Blanc）         456\n",
      "30                   起泡酒/香槟         373\n",
      "24             马尔贝克（Malbec）         338\n",
      "28                 冰酒/贵腐/甜酒         304\n",
      "22          黑皮诺（Pinot Noir）         274\n",
      "29           匹诺塔吉（Pinotage）         134\n",
      "31         桑娇维塞（Sangiovese）         107\n",
      "25                佳美（Gamay）         104\n",
      "20            雷司令（Riesling）         101\n",
      "32           仙粉黛（Zinfandel）          20\n"
     ]
    }
   ],
   "source": [
    "feature_importance=pd.DataFrame(list(model.get_booster().get_fscore().items()),\n",
    "columns=['feature','importance']).sort_values('importance', ascending=False)\n",
    "print('',feature_importance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "掌握特征的重要性排列之后，我们可以选择部分特征再做训练，对比之前的效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(13242, 21)\n",
      "(13242,)\n",
      "accuarcy: 76.52%\n",
      "[3. 2. 3. ... 4. 4. 4.]\n",
      "[0 6 3 ... 5 4 3]\n",
      "accuarcy: 22.05%\n"
     ]
    }
   ],
   "source": [
    "# 掌握特征重要性之后重新再训练\n",
    "choose = list(feature_importance[feature_importance.importance>600][\"feature\"])\n",
    "# 划分X,Y\n",
    "# X = df[df.columns.difference(['price'])]  \n",
    "X = df[choose]\n",
    "Y = df['price']\n",
    "print(X.shape)\n",
    "print(Y.shape)\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "le = LabelEncoder()\n",
    "features = [col for col in X.columns.values if X[col].dtype == \"object\"]         #筛选出object类型的特征\n",
    "for f in features:\n",
    "    X[f] = le.fit_transform(X[f])\n",
    "    \n",
    "    \n",
    "from sklearn.model_selection import train_test_split  \n",
    "\n",
    "# 划分数据训练集，测试集\n",
    "# 80%训练集，20%的测试集；为了复现实验，设置一个随机数,划分结果是确定的\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2, random_state = 55 )  \n",
    "\n",
    "# 模型相关（载入模型--训练模型--模型预测）\n",
    "from xgboost import XGBClassifier\n",
    "model = XGBClassifier(learning_rate=0.15, n_estimators=150, objective= \"multi:softmax\", num_class=8, max_depth=12, subsample =0.95)\n",
    "model.fit(x_train,y_train)            # 训练模型（训练集）\n",
    "y_pred = model.predict(x_test)        # 模型预测（测试集），y_pred为预测结果\n",
    "\n",
    "# 性能评估\n",
    "from sklearn.metrics import accuracy_score   # 准确率\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"accuarcy: %.2f%%\" % (accuracy*100.0))\n",
    "\n",
    "Y = le.fit_transform(df['price'].astype(str))\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2, random_state = 55 ) \n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "rf_params = {\"max_depth\": 8, \"max_features\": 8, \"n_estimators\": 132}\n",
    "rf = RandomForestRegressor(**rf_params, random_state=55)\n",
    "rf.fit(x_train,y_train)             # 训练模型（训练集）\n",
    "y_pred = rf.predict(x_test)\n",
    "print(y_pred.round())\n",
    "print(y_test)\n",
    "from sklearn.metrics import accuracy_score   # 准确率\n",
    "accuracy = accuracy_score(y_test,y_pred.round())\n",
    "print(\"accuarcy: %.2f%%\" % (accuracy*100.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可见模型的准确率并不是很高，提高准确率的方法有三个方向：\n",
    "\n",
    "1、区间数设置：我们定义的红酒价格区间是自己设立的，可以根据真实数据的效果修改区间数，再做尝试构建预测模型。\n",
    "\n",
    "2、准确的数据：数据的来源是京东，且在处理价格的时候是采用jieba分词及语法的形式对瓶数进行提取，可能会存在识别错的情况，即引入了脏数据，可以把处理条件更严格一些，或者爬取更为准确的数据，或者加入人工删选的步骤保证数据的准确度。\n",
    "\n",
    "3、算法选择：本案例中采用的方法是xgboost，采用的是其默认参数，可以修改参数优化模型，也可以尝试其他算法，同样的，还可以做多算法的融合结果。\n",
    "\n",
    "本案例不做拓展，学生可尝试从这三个方向提高其准确率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 步骤8：保存模型\n",
    "\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(model, open(\"pima.pickle.dat\", \"wb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "************************************************\n",
    "## 六、实验总结\n",
    "本节完整的学习构建了一个机器学习模型，流程如下：\n",
    "\n",
    "1.读取数据（判别是否需要采样）\n",
    "\n",
    "2.处理数据\n",
    "\n",
    "3.划分数据\n",
    "\n",
    "4.训练模型\n",
    "\n",
    "5.特征选择再训练\n",
    "\n",
    "下节，我们将学习如何使用训练出来的模型。\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\" >\n",
    "<li><a href=\"#ref10\" >返回目录表</a></li>   \n",
    "<br>\n",
    "<p></p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*****************************************************************\n",
    "************************************************************\n",
    "<a id=\"ref12\"></a>\n",
    "<h2 align=center>实验4-2 基于模型辅助商家实现价格发现</h2>\n",
    "\n",
    "建议课时：20分钟\n",
    "## 一、实验目的\n",
    "\n",
    "1、了解数据预测的处理流程\n",
    "\n",
    "2、了解大屏展示与业务相结合的方法\n",
    "\n",
    "## 二、实验环境\n",
    "Python3开发环境，第三方包有pandas，sklearn，xgboost，pickle\n",
    "\n",
    "## 三、实验原理\n",
    "在机器学习中，我们常常需要把训练好的模型存储起来，这样在进行决策时直接将模型读出，而不需要重新训练模型，这样就大大节约了时间。Python提供的pickle模块就很好地解决了这个问题，它可以序列化对象并保存到磁盘中，并在需要的时候读取出来，任何对象都可以执行序列化操作。本节使用pickle保存和读取模型，并展现如何利用模型进行预测。\n",
    "\n",
    "## 四、实验步骤\n",
    "本节处理的内容有：\n",
    "\n",
    "1.基于模型预测\n",
    "本节讲述的是如何拿现有模型对单条数据进行预测，有此基础就可以对海关的红酒数据进行价格区间预测，跟报关单上的价格做对比审核。\n",
    "\n",
    "### 步骤1:读取模型，并对数据进行预测\n",
    "注意此处需要对数据进行转换，利用上一个小节保存下来的encoders.dict文件对数据做相同的转换。\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 10px\">\n",
    "代码示例：\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the true result:  0-50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/python3/lib/python3.6/site-packages/ipykernel_launcher.py:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   alcohol  keyword   year  产区  仙粉黛（Zinfandel）  佳美娜（Carmenere）  佳美（Gamay）  其它  \\\n",
      "0     12.0      189  99999   2               0               0          0   1   \n",
      "\n",
      "   内比奥罗（Nebbiolo）  冰酒/贵腐/甜酒       ...         蛇龙珠（Cabernet Gernischt）  \\\n",
      "0               0         0       ...                               0   \n",
      "\n",
      "   西拉/设拉子（Syrah/Shiraz）  赤霞珠（Cabernet Sauvignon）  起泡酒/香槟  \\\n",
      "0                     0                        0       0   \n",
      "\n",
      "   长相思（Sauvignon Blanc）  雷司令（Riesling）  霞多丽（Chardonnay）  颜色  马尔贝克（Malbec）  \\\n",
      "0                     0              0                0   0             0   \n",
      "\n",
      "   黑皮诺（Pinot Noir）  \n",
      "0                0  \n",
      "\n",
      "[1 rows x 33 columns]\n",
      "the prediction of test:  ['0-50']\n"
     ]
    }
   ],
   "source": [
    "# 加载模型\n",
    "import xgboost as xgb\n",
    "# bst = xgb.Booster({'nthread':4}) #init model\n",
    "# bst.load_model(\"xgb1.model\") # load data\n",
    "bst = pickle.load(open(\"pima.pickle.dat\", \"rb\"))\n",
    "\n",
    "# 载入测试数据\n",
    "test_data = df.iloc[[0]]\n",
    "test = test_data[test_data.columns.difference(['price'])]     \n",
    "Y = test_data['price']\n",
    "print(\"the true result: \",Y[0])\n",
    "\n",
    "# 转换数据\n",
    "coders = {}\n",
    "with open(\"encoders.dict\", \"rb\") as f:\n",
    "    coders = pickle.load(f)\n",
    "aa = LabelEncoder()\n",
    "for x,y in coders.items():\n",
    "    aa.classes_ = y\n",
    "    test[x] = aa.transform(test[x])\n",
    "print(test)\n",
    "\n",
    "# 预测\n",
    "p = bst.predict(test[choose])\n",
    "print(\"the prediction of test: \",p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤2:生成报表\n",
    "\n",
    "我们得到了如何预测红酒价格区间的方法，本节讲述的是如何展示结果预测之后的效果，不仅仅是从数据的维度，从业务角度出发提供更多的展现效果和形态。\n",
    "\n",
    "此处介绍一个概念：风险分析——结合业务将“风险”两字体现出来，因此设立了以下几个风险评估的维度。\n",
    "将通过算法模型找出的平台上有问题的定价以矩阵的形式展现出来，总体将风险分为三个等级：\n",
    "\n",
    " 蓝色：风险等级较低，可以暂时观察；\n",
    " \n",
    " 黄色：风险等级中等，建议采取行动；\n",
    " \n",
    " 红色：风险等级较高，建议立即采取行动。\n",
    " \n",
    "### 风险等级定义方法：\n",
    "\n",
    "#### 风险频率等级： \n",
    "按店铺的有问题报价数量统计，计算方法为统计该企业在一定时间段内有风险的报关单数除以该店铺在这个时间段内所有的在售数；\n",
    "\n",
    "用A、B、C、D、E来表示等级，每个等级的区间为20%，即：\n",
    "\n",
    "A：该店铺在这个时间段内有20%或以下的价格存在风险；\n",
    "E：该店铺在这个时间段内有80%或以上的价格存在风险\n",
    "风险后果等级：\n",
    "用数字Ⅰ-Ⅴ表示等级，Ⅰ为最轻，Ⅴ为最严重；\n",
    "申报不规范类型风险：\n",
    "以缺少关键定价要素数量为划分标准：\n",
    "如缺少一项关键定价信息，风险等级为Ⅱ；缺少两项为Ⅲ；缺少3项为Ⅳ；\n",
    "低价风险类型风险：\n",
    "以该平台单价与价格区间的最低值范围差为标准划分：\n",
    "如Ⅰ为单价与最低值的差距在5%以内；\n",
    "Ⅴ为单价与最低值的差距在20%以上；\n",
    "\n",
    "基于属性信息和价格信息，可以依据属性类别的重合程度，来进一步确定自己的价格范围，从而在最类似的产品中制定自己最具竞争力和性价比的价格，在激烈的竞争环境中获取自己独特的用户群体和市场。同时如果结合这一风险指标，判断供应商的风险等级，则更能够确保（尤其是非生产型企业）自身产品和价格上的对应以及定价的合理性。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
